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/score/director | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director/easy/EasyScoreDirector.java | package ai.timefold.solver.core.impl.score.director.easy;
import java.util.Map;
import java.util.Objects;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.ScoreExplanation;
import ai.timefold.solver.core.api.score.calculator.EasyScoreCalculator;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatch;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatchTotal;
import ai.timefold.solver.core.api.score.constraint.Indictment;
import ai.timefold.solver.core.api.score.director.ScoreDirector;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirector;
import ai.timefold.solver.core.impl.score.director.InnerScore;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
/**
* Easy java implementation of {@link ScoreDirector}, which recalculates the {@link Score}
* of the {@link PlanningSolution working solution} every time. This is non-incremental calculation, which is slow.
* This score director implementation does not support {@link ScoreExplanation#getConstraintMatchTotalMap()} and
* {@link ScoreExplanation#getIndictmentMap()}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @param <Score_> the score type to go with the solution
* @see ScoreDirector
*/
public final class EasyScoreDirector<Solution_, Score_ extends Score<Score_>>
extends AbstractScoreDirector<Solution_, Score_, EasyScoreDirectorFactory<Solution_, Score_>> {
private final EasyScoreCalculator<Solution_, Score_> easyScoreCalculator;
private EasyScoreDirector(Builder<Solution_, Score_> builder) {
super(builder);
this.easyScoreCalculator = Objects.requireNonNull(builder.easyScoreCalculator,
"The easyScoreCalculator must not be null.");
}
public EasyScoreCalculator<Solution_, Score_> getEasyScoreCalculator() {
return easyScoreCalculator;
}
@Override
public InnerScore<Score_> calculateScore() {
variableListenerSupport.assertNotificationQueuesAreEmpty();
var score = easyScoreCalculator.calculateScore(workingSolution);
setCalculatedScore(score);
return new InnerScore<>(score, -getWorkingInitScore());
}
@Override
public void setWorkingSolutionWithoutUpdatingShadows(Solution_ workingSolution) {
super.setWorkingSolutionWithoutUpdatingShadows(workingSolution, null);
}
/**
* {@link ConstraintMatch}s are not supported by this {@link ScoreDirector} implementation.
*
* @throws IllegalStateException always
* @return throws {@link IllegalStateException}
*/
@Override
public Map<String, ConstraintMatchTotal<Score_>> getConstraintMatchTotalMap() {
throw new IllegalStateException("%s is not supported by %s."
.formatted(ConstraintMatch.class.getSimpleName(), EasyScoreDirector.class.getSimpleName()));
}
/**
* {@link ConstraintMatch}s are not supported by this {@link ScoreDirector} implementation.
*
* @throws IllegalStateException always
* @return throws {@link IllegalStateException}
*/
@Override
public Map<Object, Indictment<Score_>> getIndictmentMap() {
throw new IllegalStateException("%s is not supported by %s."
.formatted(ConstraintMatch.class.getSimpleName(), EasyScoreDirector.class.getSimpleName()));
}
@Override
public boolean requiresFlushing() {
return false; // Every score calculation starts from scratch; nothing is saved.
}
@NullMarked
public static final class Builder<Solution_, Score_ extends Score<Score_>>
extends
AbstractScoreDirectorBuilder<Solution_, Score_, EasyScoreDirectorFactory<Solution_, Score_>, Builder<Solution_, Score_>> {
private @Nullable EasyScoreCalculator<Solution_, Score_> easyScoreCalculator;
public Builder(EasyScoreDirectorFactory<Solution_, Score_> scoreDirectorFactory) {
super(scoreDirectorFactory);
}
@Override
public Builder<Solution_, Score_> withConstraintMatchPolicy(ConstraintMatchPolicy constraintMatchPolicy) {
// Override; easy can never support constraint matches.
return super.withConstraintMatchPolicy(ConstraintMatchPolicy.DISABLED);
}
public Builder<Solution_, Score_> withEasyScoreCalculator(EasyScoreCalculator<Solution_, Score_> easyScoreCalculator) {
this.easyScoreCalculator = easyScoreCalculator;
return this;
}
@Override
public EasyScoreDirector<Solution_, Score_> build() {
return new EasyScoreDirector<>(this);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director/easy/EasyScoreDirectorFactory.java | package ai.timefold.solver.core.impl.score.director.easy;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.calculator.EasyScoreCalculator;
import ai.timefold.solver.core.config.score.director.ScoreDirectorFactoryConfig;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirector;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactory;
/**
* Easy implementation of {@link ScoreDirectorFactory}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @param <Score_> the score type to go with the solution
* @see EasyScoreDirector
* @see ScoreDirectorFactory
*/
public final class EasyScoreDirectorFactory<Solution_, Score_ extends Score<Score_>>
extends AbstractScoreDirectorFactory<Solution_, Score_, EasyScoreDirectorFactory<Solution_, Score_>> {
public static <Solution_, Score_ extends Score<Score_>> EasyScoreDirectorFactory<Solution_, Score_>
buildScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor, ScoreDirectorFactoryConfig config) {
var easyScoreCalculatorClass = config.getEasyScoreCalculatorClass();
if (easyScoreCalculatorClass == null || !EasyScoreCalculator.class.isAssignableFrom(easyScoreCalculatorClass)) {
throw new IllegalArgumentException(
"The easyScoreCalculatorClass (%s) does not implement %s."
.formatted(config.getEasyScoreCalculatorClass(), EasyScoreCalculator.class.getSimpleName()));
}
EasyScoreCalculator<Solution_, Score_> easyScoreCalculator =
ConfigUtils.newInstance(config, "easyScoreCalculatorClass", easyScoreCalculatorClass);
ConfigUtils.applyCustomProperties(easyScoreCalculator, "easyScoreCalculatorClass",
config.getEasyScoreCalculatorCustomProperties(), "easyScoreCalculatorCustomProperties");
return new EasyScoreDirectorFactory<>(solutionDescriptor, easyScoreCalculator);
}
private final EasyScoreCalculator<Solution_, Score_> easyScoreCalculator;
public EasyScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor,
EasyScoreCalculator<Solution_, Score_> easyScoreCalculator) {
super(solutionDescriptor);
this.easyScoreCalculator = easyScoreCalculator;
}
@Override
public EasyScoreDirector.Builder<Solution_, Score_> createScoreDirectorBuilder() {
return new EasyScoreDirector.Builder<>(this)
.withEasyScoreCalculator(easyScoreCalculator);
}
@Override
public AbstractScoreDirector<Solution_, Score_, ?> buildScoreDirector() {
return this.createScoreDirectorBuilder().build();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director/incremental/IncrementalScoreDirector.java | package ai.timefold.solver.core.impl.score.director.incremental;
import static java.util.function.Function.identity;
import static java.util.stream.Collectors.toMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Objects;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.calculator.ConstraintMatchAwareIncrementalScoreCalculator;
import ai.timefold.solver.core.api.score.calculator.IncrementalScoreCalculator;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatch;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatchTotal;
import ai.timefold.solver.core.api.score.constraint.Indictment;
import ai.timefold.solver.core.api.score.director.ScoreDirector;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
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.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.constraint.DefaultIndictment;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirector;
import ai.timefold.solver.core.impl.score.director.InnerScore;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
/**
* Incremental java implementation of {@link ScoreDirector}, which only recalculates the {@link Score}
* of the part of the {@link PlanningSolution working solution} that changed,
* instead of the going through the entire {@link PlanningSolution}. This is incremental calculation, which is fast.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @param <Score_> the score type to go with the solution
* @see ScoreDirector
*/
public final class IncrementalScoreDirector<Solution_, Score_ extends Score<Score_>>
extends AbstractScoreDirector<Solution_, Score_, IncrementalScoreDirectorFactory<Solution_, Score_>> {
private final IncrementalScoreCalculator<Solution_, Score_> incrementalScoreCalculator;
private IncrementalScoreDirector(Builder<Solution_, Score_> builder) {
super(builder);
this.incrementalScoreCalculator = Objects.requireNonNull(builder.incrementalScoreCalculator,
"The incrementalScoreCalculator must not be null.");
}
public IncrementalScoreCalculator<Solution_, Score_> getIncrementalScoreCalculator() {
return incrementalScoreCalculator;
}
// ************************************************************************
// Complex methods
// ************************************************************************
@Override
public void setWorkingSolutionWithoutUpdatingShadows(Solution_ workingSolution) {
super.setWorkingSolutionWithoutUpdatingShadows(workingSolution, null);
if (incrementalScoreCalculator instanceof ConstraintMatchAwareIncrementalScoreCalculator) {
((ConstraintMatchAwareIncrementalScoreCalculator<Solution_, ?>) incrementalScoreCalculator)
.resetWorkingSolution(workingSolution, getConstraintMatchPolicy().isEnabled());
} else {
incrementalScoreCalculator.resetWorkingSolution(workingSolution);
}
}
@Override
public InnerScore<Score_> calculateScore() {
variableListenerSupport.assertNotificationQueuesAreEmpty();
var score = Objects.requireNonNull(incrementalScoreCalculator.calculateScore(),
() -> "The incrementalScoreCalculator (%s) must return a non-null score in the method calculateScore()."
.formatted(incrementalScoreCalculator));
setCalculatedScore(score);
return new InnerScore<>(score, -getWorkingInitScore());
}
@Override
public Map<String, ConstraintMatchTotal<Score_>> getConstraintMatchTotalMap() {
if (!constraintMatchPolicy.isEnabled()) {
throw new IllegalStateException("When constraint matching (" + constraintMatchPolicy
+ ") is disabled in the constructor, this method should not be called.");
}
// Notice that we don't trigger the variable listeners
return ((ConstraintMatchAwareIncrementalScoreCalculator<Solution_, Score_>) incrementalScoreCalculator)
.getConstraintMatchTotals()
.stream()
.collect(toMap(c -> c.getConstraintRef().constraintId(), identity()));
}
@Override
public Map<Object, Indictment<Score_>> getIndictmentMap() {
if (!constraintMatchPolicy.isJustificationEnabled()) {
throw new IllegalStateException("When constraint matching with justifications (" + constraintMatchPolicy
+ ") is disabled in the constructor, this method should not be called.");
}
Map<Object, Indictment<Score_>> incrementalIndictmentMap =
((ConstraintMatchAwareIncrementalScoreCalculator<Solution_, Score_>) incrementalScoreCalculator)
.getIndictmentMap();
if (incrementalIndictmentMap != null) {
return incrementalIndictmentMap;
}
Map<Object, Indictment<Score_>> indictmentMap = new LinkedHashMap<>();
Score_ zeroScore = getScoreDefinition().getZeroScore();
Map<String, ConstraintMatchTotal<Score_>> constraintMatchTotalMap = getConstraintMatchTotalMap();
for (ConstraintMatchTotal<Score_> constraintMatchTotal : constraintMatchTotalMap.values()) {
for (ConstraintMatch<Score_> constraintMatch : constraintMatchTotal.getConstraintMatchSet()) {
constraintMatch.getIndictedObjectList()
.stream()
.filter(Objects::nonNull)
.distinct() // One match might have the same indictment twice.
.forEach(fact -> {
DefaultIndictment<Score_> indictment =
(DefaultIndictment<Score_>) indictmentMap.computeIfAbsent(fact,
k -> new DefaultIndictment<>(fact, zeroScore));
indictment.addConstraintMatch(constraintMatch);
});
}
}
return indictmentMap;
}
@Override
public boolean requiresFlushing() {
return true; // Incremental may decide to keep events for delayed processing.
}
// ************************************************************************
// Entity/variable add/change/remove methods
// ************************************************************************
@Override
public void beforeEntityAdded(EntityDescriptor<Solution_> entityDescriptor, Object entity) {
incrementalScoreCalculator.beforeEntityAdded(entity);
super.beforeEntityAdded(entityDescriptor, entity);
}
@Override
public void afterEntityAdded(EntityDescriptor<Solution_> entityDescriptor, Object entity) {
incrementalScoreCalculator.afterEntityAdded(entity);
super.afterEntityAdded(entityDescriptor, entity);
}
@Override
public void beforeVariableChanged(VariableDescriptor variableDescriptor, Object entity) {
incrementalScoreCalculator.beforeVariableChanged(entity, variableDescriptor.getVariableName());
super.beforeVariableChanged(variableDescriptor, entity);
}
@Override
public void afterVariableChanged(VariableDescriptor variableDescriptor, Object entity) {
incrementalScoreCalculator.afterVariableChanged(entity, variableDescriptor.getVariableName());
super.afterVariableChanged(variableDescriptor, entity);
}
// TODO Add support for list variable (https://issues.redhat.com/browse/PLANNER-2711).
@Override
public void beforeListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
incrementalScoreCalculator.beforeListVariableElementAssigned(variableDescriptor.getVariableName(), element);
super.beforeListVariableElementAssigned(variableDescriptor, element);
}
@Override
public void afterListVariableElementAssigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
incrementalScoreCalculator.afterListVariableElementAssigned(variableDescriptor.getVariableName(), element);
super.afterListVariableElementAssigned(variableDescriptor, element);
}
@Override
public void beforeListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
incrementalScoreCalculator.beforeListVariableElementUnassigned(variableDescriptor.getVariableName(), element);
super.beforeListVariableElementUnassigned(variableDescriptor, element);
}
@Override
public void afterListVariableElementUnassigned(ListVariableDescriptor<Solution_> variableDescriptor, Object element) {
incrementalScoreCalculator.afterListVariableElementUnassigned(variableDescriptor.getVariableName(), element);
super.afterListVariableElementUnassigned(variableDescriptor, element);
}
@Override
public void beforeListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor, Object entity, int fromIndex,
int toIndex) {
incrementalScoreCalculator.beforeListVariableChanged(entity, variableDescriptor.getVariableName(), fromIndex, toIndex);
super.beforeListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
}
@Override
public void afterListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor, Object entity, int fromIndex,
int toIndex) {
incrementalScoreCalculator.afterListVariableChanged(entity, variableDescriptor.getVariableName(), fromIndex, toIndex);
super.afterListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
}
@Override
public void beforeEntityRemoved(EntityDescriptor<Solution_> entityDescriptor, Object entity) {
incrementalScoreCalculator.beforeEntityRemoved(entity);
super.beforeEntityRemoved(entityDescriptor, entity);
}
@Override
public void afterEntityRemoved(EntityDescriptor<Solution_> entityDescriptor, Object entity) {
incrementalScoreCalculator.afterEntityRemoved(entity);
super.afterEntityRemoved(entityDescriptor, entity);
}
// ************************************************************************
// Problem fact add/change/remove methods
// ************************************************************************
@Override
public void beforeProblemFactAdded(Object problemFact) {
super.beforeProblemFactAdded(problemFact);
}
@Override
public void afterProblemFactAdded(Object problemFact) {
incrementalScoreCalculator.resetWorkingSolution(workingSolution); // TODO do not nuke it
super.afterProblemFactAdded(problemFact);
}
@Override
public void beforeProblemPropertyChanged(Object problemFactOrEntity) {
super.beforeProblemPropertyChanged(problemFactOrEntity);
}
@Override
public void afterProblemPropertyChanged(Object problemFactOrEntity) {
incrementalScoreCalculator.resetWorkingSolution(workingSolution); // TODO do not nuke it
super.afterProblemPropertyChanged(problemFactOrEntity);
}
@Override
public void beforeProblemFactRemoved(Object problemFact) {
super.beforeProblemFactRemoved(problemFact);
}
@Override
public void afterProblemFactRemoved(Object problemFact) {
incrementalScoreCalculator.resetWorkingSolution(workingSolution); // TODO do not nuke it
super.afterProblemFactRemoved(problemFact);
}
@NullMarked
public static final class Builder<Solution_, Score_ extends Score<Score_>>
extends
AbstractScoreDirectorBuilder<Solution_, Score_, IncrementalScoreDirectorFactory<Solution_, Score_>, Builder<Solution_, Score_>> {
private @Nullable IncrementalScoreCalculator<Solution_, Score_> incrementalScoreCalculator;
public Builder(IncrementalScoreDirectorFactory<Solution_, Score_> scoreDirectorFactory) {
super(scoreDirectorFactory);
}
public Builder<Solution_, Score_>
withIncrementalScoreCalculator(IncrementalScoreCalculator<Solution_, Score_> incrementalScoreCalculator) {
this.incrementalScoreCalculator = incrementalScoreCalculator;
return withConstraintMatchPolicy(constraintMatchPolicy); // Ensure the policy is correct for the calculator.
}
@Override
public Builder<Solution_, Score_> withConstraintMatchPolicy(ConstraintMatchPolicy constraintMatchPolicy) {
return super.withConstraintMatchPolicy(determineCorrectPolicy(constraintMatchPolicy, incrementalScoreCalculator));
}
@Override
public IncrementalScoreDirector<Solution_, Score_> build() {
return new IncrementalScoreDirector<>(this);
}
private static ConstraintMatchPolicy determineCorrectPolicy(ConstraintMatchPolicy constraintMatchPolicy,
IncrementalScoreCalculator<?, ?> incrementalScoreCalculator) {
if (incrementalScoreCalculator instanceof ConstraintMatchAwareIncrementalScoreCalculator<?, ?>) {
return constraintMatchPolicy;
} else {
return ConstraintMatchPolicy.DISABLED;
}
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director/incremental/IncrementalScoreDirectorFactory.java | package ai.timefold.solver.core.impl.score.director.incremental;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.calculator.ConstraintMatchAwareIncrementalScoreCalculator;
import ai.timefold.solver.core.api.score.calculator.IncrementalScoreCalculator;
import ai.timefold.solver.core.config.score.director.ScoreDirectorFactoryConfig;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactory;
/**
* Incremental implementation of {@link ScoreDirectorFactory}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @param <Score_> the score type to go with the solution
* @see IncrementalScoreDirector
* @see ScoreDirectorFactory
*/
public final class IncrementalScoreDirectorFactory<Solution_, Score_ extends Score<Score_>>
extends AbstractScoreDirectorFactory<Solution_, Score_, IncrementalScoreDirectorFactory<Solution_, Score_>> {
public static <Solution_, Score_ extends Score<Score_>> IncrementalScoreDirectorFactory<Solution_, Score_>
buildScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor, ScoreDirectorFactoryConfig config) {
if (!IncrementalScoreCalculator.class.isAssignableFrom(config.getIncrementalScoreCalculatorClass())) {
throw new IllegalArgumentException(
"The incrementalScoreCalculatorClass (%s) does not implement %s."
.formatted(config.getIncrementalScoreCalculatorClass(),
IncrementalScoreCalculator.class.getSimpleName()));
}
return new IncrementalScoreDirectorFactory<>(solutionDescriptor, () -> {
IncrementalScoreCalculator<Solution_, Score_> incrementalScoreCalculator = ConfigUtils.newInstance(config,
"incrementalScoreCalculatorClass", config.getIncrementalScoreCalculatorClass());
ConfigUtils.applyCustomProperties(incrementalScoreCalculator, "incrementalScoreCalculatorClass",
config.getIncrementalScoreCalculatorCustomProperties(), "incrementalScoreCalculatorCustomProperties");
return incrementalScoreCalculator;
});
}
private final Supplier<IncrementalScoreCalculator<Solution_, Score_>> incrementalScoreCalculatorSupplier;
public IncrementalScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor,
Supplier<IncrementalScoreCalculator<Solution_, Score_>> incrementalScoreCalculatorSupplier) {
super(solutionDescriptor);
this.incrementalScoreCalculatorSupplier = incrementalScoreCalculatorSupplier;
}
@Override
public boolean supportsConstraintMatching() {
return incrementalScoreCalculatorSupplier.get() instanceof ConstraintMatchAwareIncrementalScoreCalculator;
}
@Override
public IncrementalScoreDirector.Builder<Solution_, Score_> createScoreDirectorBuilder() {
return new IncrementalScoreDirector.Builder<>(this)
.withIncrementalScoreCalculator(incrementalScoreCalculatorSupplier.get());
}
@Override
public IncrementalScoreDirector<Solution_, Score_> buildScoreDirector() {
return createScoreDirectorBuilder().build();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director/stream/BavetConstraintStreamScoreDirector.java | package ai.timefold.solver.core.impl.score.director.stream;
import java.util.ArrayList;
import java.util.Map;
import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
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.api.score.constraint.Indictment;
import ai.timefold.solver.core.api.score.director.ScoreDirector;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.ConsistencyTracker;
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.score.director.AbstractScoreDirector;
import ai.timefold.solver.core.impl.score.director.InnerScore;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintSession;
import org.jspecify.annotations.NullMarked;
/**
* FP streams implementation of {@link ScoreDirector}, which only recalculates the {@link Score}
* of the part of the {@link PlanningSolution working solution} that changed,
* instead of the going through the entire {@link PlanningSolution}. This is incremental calculation, which is fast.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see ScoreDirector
*/
public final class BavetConstraintStreamScoreDirector<Solution_, Score_ extends Score<Score_>>
extends AbstractScoreDirector<Solution_, Score_, BavetConstraintStreamScoreDirectorFactory<Solution_, Score_>> {
private final boolean derived;
private BavetConstraintSession<Score_> session;
private BavetConstraintStreamScoreDirector(Builder<Solution_, Score_> builder, boolean derived) {
super(builder);
this.derived = derived;
}
// ************************************************************************
// Complex methods
// ************************************************************************
/**
* The function is exclusively available for the Bavet score director, and its use must be approached with caution.
* The primary purpose of this method is
* to enable the {@code ConstraintVerifier}
* to ignore events related to shadow variables when testing constraints that do not rely on them.
*
* @see AbstractScoreDirector#clearVariableListenerEvents()
*/
public void clearShadowVariablesListenerQueue() {
clearVariableListenerEvents();
}
/**
* The function is exclusively available for the Bavet score director, and its use must be approached with caution.
* The primary purpose of this method is
* to enable the {@code ConstraintVerifier}
* to update the consistency status of entities in the solution without updating shadows.
* <p>
* This must be done before setWorkingSolutionWithoutUpdatingShadows, which inserts the entities.
*/
public void updateConsistencyFromSolution(Solution_ solution) {
var solutionDescriptor = getSolutionDescriptor();
var entityList = new ArrayList<>();
solutionDescriptor.visitAllEntities(solution, entityList::add);
variableListenerSupport.setConsistencyTracker(ConsistencyTracker.frozen(
getSolutionDescriptor(),
entityList.toArray()));
}
@Override
public void setWorkingSolutionWithoutUpdatingShadows(Solution_ workingSolution) {
session = scoreDirectorFactory.newSession(workingSolution, variableListenerSupport.getConsistencyTracker(),
constraintMatchPolicy, derived);
super.setWorkingSolutionWithoutUpdatingShadows(workingSolution, session::insert);
}
@Override
public InnerScore<Score_> calculateScore() {
variableListenerSupport.assertNotificationQueuesAreEmpty();
var score = session.calculateScore();
setCalculatedScore(score);
return new InnerScore<>(score, -getWorkingInitScore());
}
@Override
public Map<String, ConstraintMatchTotal<Score_>> getConstraintMatchTotalMap() {
if (!constraintMatchPolicy.isEnabled()) {
throw new IllegalStateException("When constraint matching is disabled, this method should not be called.");
} else if (workingSolution == null) {
throw new IllegalStateException(
"The method setWorkingSolution() must be called before the method getConstraintMatchTotalMap().");
}
return session.getConstraintMatchTotalMap();
}
@Override
public Map<Object, Indictment<Score_>> getIndictmentMap() {
if (!constraintMatchPolicy.isJustificationEnabled()) {
throw new IllegalStateException(
"When constraint matching with justifications is disabled, this method should not be called.");
} else if (workingSolution == null) {
throw new IllegalStateException(
"The method setWorkingSolution() must be called before the method getIndictmentMap().");
}
return session.getIndictmentMap();
}
@Override
public boolean requiresFlushing() {
return true; // Tuple refresh happens during score calculation.
}
@Override
public void close() {
super.close();
if (session != null) {
session = null;
}
}
// ************************************************************************
// Entity/variable add/change/remove methods
// ************************************************************************
// public void beforeEntityAdded(EntityDescriptor entityDescriptor, Object entity) // Do nothing
@Override
public void afterEntityAdded(EntityDescriptor<Solution_> entityDescriptor, Object entity) {
if (entity == null) {
throw new IllegalArgumentException("The entity (%s) cannot be added to the ScoreDirector.".formatted(entity));
}
if (!getSolutionDescriptor().hasEntityDescriptor(entity.getClass())) {
throw new IllegalArgumentException("The entity (%s) of class (%s) is not a configured @%s.".formatted(entity,
entity.getClass(), PlanningEntity.class.getSimpleName()));
}
session.insert(entity);
super.afterEntityAdded(entityDescriptor, entity);
}
// public void beforeVariableChanged(VariableDescriptor variableDescriptor, Object entity) // Do nothing
@Override
public void afterVariableChanged(VariableDescriptor<Solution_> variableDescriptor, Object entity) {
session.update(entity);
super.afterVariableChanged(variableDescriptor, entity);
}
@Override
public void afterListVariableChanged(ListVariableDescriptor<Solution_> variableDescriptor, Object entity, int fromIndex,
int toIndex) {
session.update(entity);
super.afterListVariableChanged(variableDescriptor, entity, fromIndex, toIndex);
}
// public void beforeEntityRemoved(EntityDescriptor entityDescriptor, Object entity) // Do nothing
@Override
public void afterEntityRemoved(EntityDescriptor<Solution_> entityDescriptor, Object entity) {
session.retract(entity);
super.afterEntityRemoved(entityDescriptor, entity);
}
// ************************************************************************
// Problem fact add/change/remove methods
// ************************************************************************
// public void beforeProblemFactAdded(Object problemFact) // Do nothing
@Override
public void afterProblemFactAdded(Object problemFact) {
if (problemFact == null) {
throw new IllegalArgumentException(
"The problemFact (%s) cannot be added to the ScoreDirector.".formatted(problemFact));
}
session.insert(problemFact);
super.afterProblemFactAdded(problemFact);
}
// public void beforeProblemPropertyChanged(Object problemFactOrEntity) // Do nothing
@Override
public void afterProblemPropertyChanged(Object problemFactOrEntity) {
session.update(problemFactOrEntity);
super.afterProblemPropertyChanged(problemFactOrEntity);
}
// public void beforeProblemFactRemoved(Object problemFact) // Do nothing
@Override
public void afterProblemFactRemoved(Object problemFact) {
session.retract(problemFact);
super.afterProblemFactRemoved(problemFact);
}
/**
* Exposed for debugging purposes, so that we can hook into it from tests and while reproducing issues.
*
* @return null before first {@link #setWorkingSolutionWithoutUpdatingShadows(Object)} or after {@link #close()}.
*/
@SuppressWarnings("unused")
public BavetConstraintSession<Score_> getSession() {
return session;
}
@Override
public boolean isDerived() {
return derived;
}
@NullMarked
public static final class Builder<Solution_, Score_ extends Score<Score_>>
extends
AbstractScoreDirectorBuilder<Solution_, Score_, BavetConstraintStreamScoreDirectorFactory<Solution_, Score_>, Builder<Solution_, Score_>> {
public Builder(BavetConstraintStreamScoreDirectorFactory<Solution_, Score_> scoreDirectorFactory) {
super(scoreDirectorFactory);
}
@Override
public BavetConstraintStreamScoreDirector<Solution_, Score_> build() {
return new BavetConstraintStreamScoreDirector<>(this, false);
}
@Override
public AbstractScoreDirector<Solution_, Score_, BavetConstraintStreamScoreDirectorFactory<Solution_, Score_>>
buildDerived() {
return new BavetConstraintStreamScoreDirector<>(this, true);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director/stream/BavetConstraintStreamScoreDirectorFactory.java | package ai.timefold.solver.core.impl.score.director.stream;
import java.util.Arrays;
import java.util.function.Consumer;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintMetaModel;
import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
import ai.timefold.solver.core.config.score.director.ScoreDirectorFactoryConfig;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.enterprise.TimefoldSolverEnterpriseService;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.ConsistencyTracker;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirector;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintSession;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintSessionFactory;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraintStreamScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.stream.common.inliner.AbstractScoreInliner;
public final class BavetConstraintStreamScoreDirectorFactory<Solution_, Score_ extends Score<Score_>>
extends
AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_, BavetConstraintStreamScoreDirectorFactory<Solution_, Score_>> {
public static <Solution_, Score_ extends Score<Score_>> BavetConstraintStreamScoreDirectorFactory<Solution_, Score_>
buildScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor, ScoreDirectorFactoryConfig config,
EnvironmentMode environmentMode) {
var providedConstraintProviderClass = config.getConstraintProviderClass();
if (providedConstraintProviderClass == null
|| !ConstraintProvider.class.isAssignableFrom(providedConstraintProviderClass)) {
throw new IllegalArgumentException(
"The constraintProviderClass (%s) does not implement %s."
.formatted(providedConstraintProviderClass, ConstraintProvider.class.getSimpleName()));
}
var constraintProviderClass = getConstraintProviderClass(config, providedConstraintProviderClass);
var constraintProvider = ConfigUtils.newInstance(config, "constraintProviderClass", constraintProviderClass);
ConfigUtils.applyCustomProperties(constraintProvider, "constraintProviderClass",
config.getConstraintProviderCustomProperties(), "constraintProviderCustomProperties");
return new BavetConstraintStreamScoreDirectorFactory<>(solutionDescriptor, constraintProvider, environmentMode);
}
private static Class<? extends ConstraintProvider> getConstraintProviderClass(ScoreDirectorFactoryConfig config,
Class<? extends ConstraintProvider> providedConstraintProviderClass) {
if (Boolean.TRUE.equals(config.getConstraintStreamAutomaticNodeSharing())) {
var enterpriseService =
TimefoldSolverEnterpriseService.loadOrFail(TimefoldSolverEnterpriseService.Feature.AUTOMATIC_NODE_SHARING);
return enterpriseService.buildLambdaSharedConstraintProvider(config.getConstraintProviderClass());
} else {
return providedConstraintProviderClass;
}
}
private final BavetConstraintSessionFactory<Solution_, Score_> constraintSessionFactory;
private final ConstraintMetaModel constraintMetaModel;
public BavetConstraintStreamScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor,
ConstraintProvider constraintProvider, EnvironmentMode environmentMode) {
super(solutionDescriptor);
var constraintFactory = new BavetConstraintFactory<>(solutionDescriptor, environmentMode);
constraintMetaModel = DefaultConstraintMetaModel.of(constraintFactory.buildConstraints(constraintProvider));
constraintSessionFactory = new BavetConstraintSessionFactory<>(solutionDescriptor, constraintMetaModel);
}
public BavetConstraintSession<Score_> newSession(Solution_ workingSolution,
ConsistencyTracker<Solution_> consistencyTracker,
ConstraintMatchPolicy constraintMatchPolicy,
boolean scoreDirectorDerived) {
return newSession(workingSolution, consistencyTracker, constraintMatchPolicy, scoreDirectorDerived, null);
}
public BavetConstraintSession<Score_> newSession(Solution_ workingSolution,
ConsistencyTracker<Solution_> consistencyTracker,
ConstraintMatchPolicy constraintMatchPolicy,
boolean scoreDirectorDerived, Consumer<String> nodeNetworkVisualizationConsumer) {
return constraintSessionFactory.buildSession(workingSolution, consistencyTracker, constraintMatchPolicy,
scoreDirectorDerived,
nodeNetworkVisualizationConsumer);
}
@Override
public AbstractScoreInliner<Score_> fireAndForget(Object... facts) {
var consistencyTracker = ConsistencyTracker.frozen(solutionDescriptor, facts);
var session = newSession(null, consistencyTracker,
ConstraintMatchPolicy.ENABLED, true);
Arrays.stream(facts).forEach(session::insert);
session.calculateScore();
return session.getScoreInliner();
}
@Override
public ConstraintMetaModel getConstraintMetaModel() {
return constraintMetaModel;
}
@Override
public BavetConstraintStreamScoreDirector.Builder<Solution_, Score_> createScoreDirectorBuilder() {
return new BavetConstraintStreamScoreDirector.Builder<>(this);
}
@Override
public AbstractScoreDirector<Solution_, Score_, ?> buildScoreDirector() {
return createScoreDirectorBuilder().build();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/director/stream/DefaultConstraintMetaModel.java | package ai.timefold.solver.core.impl.score.director.stream;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintMetaModel;
import ai.timefold.solver.core.impl.util.CollectionUtils;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
record DefaultConstraintMetaModel(
Map<ConstraintRef, Constraint> constraintPerRefMap,
Map<String, List<Constraint>> constraintPerGroupMap) implements ConstraintMetaModel {
public static ConstraintMetaModel of(List<? extends Constraint> constraints) {
var constraintCount = constraints.size();
// Preserve iteration order by using LinkedHashMap.
var perRefMap = CollectionUtils.<ConstraintRef, Constraint> newLinkedHashMap(constraintCount);
var perGroupMap = new TreeMap<String, List<Constraint>>();
for (var constraint : constraints) {
perRefMap.put(constraint.getConstraintRef(), constraint);
// The list is used to preserve iteration order of the constraints.
// Constraint groups are an optional feature, therefore most people won't use them,
// therefore sizing the list assuming all constraints end up in the default group.
perGroupMap.computeIfAbsent(constraint.getConstraintGroup(), k -> new ArrayList<>(constraintCount))
.add(constraint);
}
return new DefaultConstraintMetaModel(
Collections.unmodifiableMap(perRefMap),
Collections.unmodifiableMap(perGroupMap));
}
@Override
public @Nullable Constraint getConstraint(@NonNull ConstraintRef constraintRef) {
return constraintPerRefMap.get(constraintRef);
}
@Override
public @NonNull Collection<Constraint> getConstraintsPerGroup(@NonNull String constraintGroup) {
return constraintPerGroupMap.getOrDefault(constraintGroup, Collections.emptyList());
}
@Override
public @NonNull Set<String> getConstraintGroups() {
return constraintPerGroupMap.keySet();
}
@Override
public @NonNull Collection<Constraint> getConstraints() {
return constraintPerRefMap.values();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/BavetConstraint.java | package ai.timefold.solver.core.impl.score.stream.bavet;
import java.util.Set;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
public final class BavetConstraint<Solution_> extends
AbstractConstraint<Solution_, BavetConstraint<Solution_>, BavetConstraintFactory<Solution_>> {
private final BavetScoringConstraintStream<Solution_> scoringConstraintStream;
public BavetConstraint(BavetConstraintFactory<Solution_> constraintFactory, ConstraintRef constraintRef,
String description, String constraintGroup, Score<?> constraintWeight, ScoreImpactType scoreImpactType,
Object justificationMapping, Object indictedObjectsMapping,
BavetScoringConstraintStream<Solution_> scoringConstraintStream) {
super(constraintFactory, constraintRef, description, constraintGroup, constraintWeight, scoreImpactType,
justificationMapping, indictedObjectsMapping);
this.scoringConstraintStream = scoringConstraintStream;
}
public BavetScoringConstraintStream<Solution_> getScoringConstraintStream() {
return scoringConstraintStream;
}
@Override
public String toString() {
return "BavetConstraint(" + getConstraintRef() + ")";
}
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
scoringConstraintStream.collectActiveConstraintStreams(constraintStreamSet);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/BavetConstraintFactory.java | package ai.timefold.solver.core.impl.score.stream.bavet;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Function;
import java.util.function.Predicate;
import ai.timefold.solver.core.api.score.stream.Joiners;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.ConsistencyTracker;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetForEachUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.ForEachFilteringCriteria;
import ai.timefold.solver.core.impl.score.stream.common.InnerConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import org.jspecify.annotations.NonNull;
public final class BavetConstraintFactory<Solution_>
extends InnerConstraintFactory<Solution_, BavetConstraint<Solution_>> {
/**
* Used for code in no package, also called the "unnamed package".
* Classes here can only be instantiated via reflection,
* they cannot be imported and used directly.
* But still, in corner cases such as Kotlin notebooks,
* all code is in the unnamed package.
* Assume a constraint provider under these conditions,
* where asConstraint(...) only specifies constraint name, not constraint package.
* In this situation, the default constraint package is used.
*/
private static final String DEFAULT_CONSTRAINT_PACKAGE = "unnamed.package";
private final SolutionDescriptor<Solution_> solutionDescriptor;
private final EnvironmentMode environmentMode;
private final String defaultConstraintPackage;
private final Map<BavetAbstractConstraintStream<Solution_>, BavetAbstractConstraintStream<Solution_>> sharingStreamMap =
new HashMap<>(256);
public BavetConstraintFactory(SolutionDescriptor<Solution_> solutionDescriptor, EnvironmentMode environmentMode) {
this.solutionDescriptor = solutionDescriptor;
this.environmentMode = Objects.requireNonNull(environmentMode);
var weightSupplier = solutionDescriptor.getConstraintWeightSupplier();
if (weightSupplier == null) {
defaultConstraintPackage = determineDefaultConstraintPackage(solutionDescriptor.getSolutionClass().getPackage());
} else {
defaultConstraintPackage = determineDefaultConstraintPackage(weightSupplier.getDefaultConstraintPackage());
}
}
private static String determineDefaultConstraintPackage(Package pkg) {
var asString = pkg == null ? "" : pkg.getName();
return determineDefaultConstraintPackage(asString);
}
private static String determineDefaultConstraintPackage(String constraintPackage) {
return constraintPackage == null || constraintPackage.isEmpty() ? DEFAULT_CONSTRAINT_PACKAGE : constraintPackage;
}
public <Stream_ extends BavetAbstractConstraintStream<Solution_>> Stream_ share(Stream_ stream) {
return share(stream, t -> {
});
}
/**
* Enables node sharing.
* If a constraint already exists in this factory, it replaces it with the old copy.
* {@link BavetAbstractConstraintStream} implement equals/hashcode ignoring child streams.
* <p>
* {@link BavetConstraintSessionFactory#buildSession(Object, ConsistencyTracker, ConstraintMatchPolicy, boolean, Consumer)}
* 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 BavetAbstractConstraintStream} subclass
* @return never null
*/
public <Stream_ extends BavetAbstractConstraintStream<Solution_>> Stream_ share(Stream_ stream,
Consumer<Stream_> consumer) {
return (Stream_) sharingStreamMap.computeIfAbsent(stream, k -> {
consumer.accept(stream);
return stream;
});
}
// ************************************************************************
// from
// ************************************************************************
// Required for node sharing, since using a lambda will create different instances
private record ForEachFilteringCriteriaPredicateFunction<Solution_, A>(EntityDescriptor<Solution_> entityDescriptor,
ForEachFilteringCriteria criteria) implements Function<ConstraintNodeBuildHelper<Solution_, ?>, Predicate<A>> {
public Predicate<A> apply(@NonNull ConstraintNodeBuildHelper<Solution_, ?> helper) {
return helper.getForEachPredicateForEntityDescriptorAndCriteria(entityDescriptor, criteria);
}
}
private <A> @NonNull UniConstraintStream<A> forEachForCriteria(@NonNull Class<A> sourceClass,
ForEachFilteringCriteria criteria) {
assertValidFromType(sourceClass);
var entityDescriptor = solutionDescriptor.findEntityDescriptor(sourceClass);
if (entityDescriptor == null || criteria == ForEachFilteringCriteria.ALL) {
// Not genuine or shadow entity, or filtering was not requested; no need for filtering.
return share(new BavetForEachUniConstraintStream<>(this, sourceClass, null, RetrievalSemantics.STANDARD));
}
var listVariableDescriptor = solutionDescriptor.getListVariableDescriptor();
if (listVariableDescriptor == null || !listVariableDescriptor.acceptsValueType(sourceClass)) {
// No applicable list variable; don't need to check inverse relationships.
return share(new BavetForEachUniConstraintStream<>(this, sourceClass,
new ForEachFilteringCriteriaPredicateFunction<>(entityDescriptor, criteria),
RetrievalSemantics.STANDARD));
}
var entityClass = listVariableDescriptor.getEntityDescriptor().getEntityClass();
if (entityClass == sourceClass) {
throw new IllegalStateException("Impossible state: entityClass (%s) and sourceClass (%s) are the same."
.formatted(entityClass.getCanonicalName(), sourceClass.getCanonicalName()));
}
var shadowDescriptor = listVariableDescriptor.getInverseRelationShadowVariableDescriptor();
if (shadowDescriptor == null && criteria == ForEachFilteringCriteria.ASSIGNED_AND_CONSISTENT) {
// The list variable element doesn't have the @InverseRelationShadowVariable annotation,
// and we are not including unassigned elements.
// We don't want the users to be forced to implement it in quickstarts,
// so we'll do this expensive thing instead.
return forEachForCriteria(sourceClass, ForEachFilteringCriteria.CONSISTENT)
.ifExists((Class) entityClass,
Joiners.filtering(listVariableDescriptor.getInListPredicate()));
} else { // We have the inverse relation variable, so we can read its value directly.
return share(new BavetForEachUniConstraintStream<>(this, sourceClass,
new ForEachFilteringCriteriaPredicateFunction<>(entityDescriptor, criteria),
RetrievalSemantics.STANDARD));
}
}
@Override
public <A> @NonNull UniConstraintStream<A> forEach(@NonNull Class<A> sourceClass) {
return forEachForCriteria(sourceClass, ForEachFilteringCriteria.ASSIGNED_AND_CONSISTENT);
}
@Override
public <A> @NonNull UniConstraintStream<A> forEachIncludingUnassigned(@NonNull Class<A> sourceClass) {
return forEachForCriteria(sourceClass, ForEachFilteringCriteria.CONSISTENT);
}
@Override
public <A> @NonNull UniConstraintStream<A> forEachUnfiltered(@NonNull Class<A> sourceClass) {
return forEachForCriteria(sourceClass, ForEachFilteringCriteria.ALL);
}
// Required for node sharing, since using a lambda will create different instances
private record PredicateSupplier<Solution_, A>(
Predicate<A> suppliedPredicate) implements Function<ConstraintNodeBuildHelper<Solution_, ?>, Predicate<A>> {
public Predicate<A> apply(@NonNull ConstraintNodeBuildHelper<Solution_, ?> helper) {
return suppliedPredicate;
}
}
@Override
public @NonNull <A> UniConstraintStream<A> from(@NonNull Class<A> fromClass) {
assertValidFromType(fromClass);
var entityDescriptor = solutionDescriptor.findEntityDescriptor(fromClass);
if (entityDescriptor != null && entityDescriptor.isGenuine()) {
var predicate = (Predicate<A>) entityDescriptor.getIsInitializedPredicate();
return share(
new BavetForEachUniConstraintStream<>(this, fromClass, new PredicateSupplier<>(predicate),
RetrievalSemantics.LEGACY));
} else {
return share(new BavetForEachUniConstraintStream<>(this, fromClass, null, RetrievalSemantics.LEGACY));
}
}
@Override
public @NonNull <A> UniConstraintStream<A> fromUnfiltered(@NonNull Class<A> fromClass) {
assertValidFromType(fromClass);
return share(new BavetForEachUniConstraintStream<>(this, fromClass, null, RetrievalSemantics.LEGACY));
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return solutionDescriptor;
}
public EnvironmentMode getEnvironmentMode() {
return environmentMode;
}
@Override
public @NonNull String getDefaultConstraintPackage() {
return defaultConstraintPackage;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/BavetConstraintSession.java | package ai.timefold.solver.core.impl.score.stream.bavet;
import java.util.Map;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatchTotal;
import ai.timefold.solver.core.api.score.constraint.Indictment;
import ai.timefold.solver.core.impl.bavet.AbstractSession;
import ai.timefold.solver.core.impl.bavet.NodeNetwork;
import ai.timefold.solver.core.impl.bavet.common.PropagationQueue;
import ai.timefold.solver.core.impl.domain.variable.declarative.ConsistencyTracker;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.director.stream.BavetConstraintStreamScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.stream.common.inliner.AbstractScoreInliner;
/**
* The type is public to make it easier for Bavet-specific minimal bug reproducers to be created.
* Instances should be created through
* {@link BavetConstraintStreamScoreDirectorFactory#newSession(Object, ConsistencyTracker, ConstraintMatchPolicy, boolean)}.
*
* @see PropagationQueue Description of the tuple propagation mechanism.
*
* @param <Score_>
*/
public final class BavetConstraintSession<Score_ extends Score<Score_>> extends AbstractSession {
private final AbstractScoreInliner<Score_> scoreInliner;
BavetConstraintSession(AbstractScoreInliner<Score_> scoreInliner) {
this(scoreInliner, NodeNetwork.EMPTY);
}
BavetConstraintSession(AbstractScoreInliner<Score_> scoreInliner, NodeNetwork nodeNetwork) {
super(nodeNetwork);
this.scoreInliner = scoreInliner;
}
public Score_ calculateScore() {
settle();
return scoreInliner.extractScore();
}
public AbstractScoreInliner<Score_> getScoreInliner() {
return scoreInliner;
}
public Map<String, ConstraintMatchTotal<Score_>> getConstraintMatchTotalMap() {
return scoreInliner.getConstraintIdToConstraintMatchTotalMap();
}
public Map<Object, Indictment<Score_>> getIndictmentMap() {
return scoreInliner.getIndictmentMap();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/BavetConstraintSessionFactory.java | package ai.timefold.solver.core.impl.score.stream.bavet;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import java.util.function.Consumer;
import java.util.stream.Collectors;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintMetaModel;
import ai.timefold.solver.core.impl.bavet.NodeNetwork;
import ai.timefold.solver.core.impl.bavet.common.AbstractNodeBuildHelper;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.uni.AbstractForEachUniNode;
import ai.timefold.solver.core.impl.bavet.visual.NodeGraph;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.ConsistencyTracker;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.common.inliner.AbstractScoreInliner;
import ai.timefold.solver.core.impl.util.CollectionUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import org.slf4j.event.Level;
public final class BavetConstraintSessionFactory<Solution_, Score_ extends Score<Score_>> {
private static final Logger LOGGER = LoggerFactory.getLogger(BavetConstraintSessionFactory.class);
private static final Level CONSTRAINT_WEIGHT_LOGGING_LEVEL = Level.DEBUG;
private final SolutionDescriptor<Solution_> solutionDescriptor;
private final ConstraintMetaModel constraintMetaModel;
public BavetConstraintSessionFactory(SolutionDescriptor<Solution_> solutionDescriptor,
ConstraintMetaModel constraintMetaModel) {
this.solutionDescriptor = Objects.requireNonNull(solutionDescriptor);
this.constraintMetaModel = Objects.requireNonNull(constraintMetaModel);
}
// ************************************************************************
// Node creation
// ************************************************************************
@SuppressWarnings("unchecked")
public BavetConstraintSession<Score_> buildSession(Solution_ workingSolution,
ConsistencyTracker<Solution_> consistencyTracker,
ConstraintMatchPolicy constraintMatchPolicy,
boolean scoreDirectorDerived, Consumer<String> nodeNetworkVisualizationConsumer) {
var constraintWeightSupplier = solutionDescriptor.getConstraintWeightSupplier();
var constraints = constraintMetaModel.getConstraints();
if (constraintWeightSupplier != null) { // Fail fast on unknown constraints.
var knownConstraints = constraints.stream()
.map(Constraint::getConstraintRef)
.collect(Collectors.toSet());
constraintWeightSupplier.validate(workingSolution, knownConstraints);
}
var scoreDefinition = solutionDescriptor.<Score_> getScoreDefinition();
var zeroScore = scoreDefinition.getZeroScore();
var constraintStreamSet = new LinkedHashSet<BavetAbstractConstraintStream<Solution_>>();
var constraintWeightMap = CollectionUtils.<Constraint, Score_> newHashMap(constraints.size());
// Only log constraint weights if logging is enabled; otherwise we don't need to build the string.
var constraintWeightLoggingEnabled = !scoreDirectorDerived && LOGGER.isEnabledForLevel(CONSTRAINT_WEIGHT_LOGGING_LEVEL);
var constraintWeightString = constraintWeightLoggingEnabled
? new StringBuilder("Constraint weights for solution (%s):%n"
.formatted(workingSolution))
: null;
for (var constraint : constraints) {
var constraintRef = constraint.getConstraintRef();
var castConstraint = (BavetConstraint<Solution_>) constraint;
var defaultConstraintWeight = castConstraint.getConstraintWeight();
var constraintWeight = (Score_) castConstraint.extractConstraintWeight(workingSolution);
if (!constraintWeight.equals(zeroScore)) {
if (constraintWeightLoggingEnabled) {
if (defaultConstraintWeight != null && !defaultConstraintWeight.equals(constraintWeight)) {
constraintWeightString.append(" Constraint (%s) weight overridden to (%s) from (%s).%n"
.formatted(constraintRef, constraintWeight, defaultConstraintWeight));
} else {
constraintWeightString.append(" Constraint (%s) weight set to (%s).%n"
.formatted(constraintRef, constraintWeight));
}
}
/*
* Relies on BavetConstraintFactory#share(Stream_) occurring for all constraint stream instances
* to ensure there are no 2 equal ConstraintStream instances (with different child stream lists).
*/
castConstraint.collectActiveConstraintStreams(constraintStreamSet);
constraintWeightMap.put(constraint, constraintWeight);
} else {
if (constraintWeightLoggingEnabled) {
/*
* Filter out nodes that only lead to constraints with zero weight.
* Note: Node sharing happens earlier, in BavetConstraintFactory#share(Stream_).
*/
constraintWeightString.append(" Constraint (%s) disabled.%n"
.formatted(constraintRef));
}
}
}
var scoreInliner = AbstractScoreInliner.buildScoreInliner(scoreDefinition, constraintWeightMap, constraintMatchPolicy);
if (constraintStreamSet.isEmpty()) {
LOGGER.warn("No constraints enabled for solution ({}).", workingSolution);
return new BavetConstraintSession<>(scoreInliner);
}
if (constraintWeightLoggingEnabled) {
LOGGER.atLevel(CONSTRAINT_WEIGHT_LOGGING_LEVEL)
.log(constraintWeightString.toString().trim());
}
return new BavetConstraintSession<>(scoreInliner,
buildNodeNetwork(workingSolution, consistencyTracker, constraintStreamSet, scoreInliner,
nodeNetworkVisualizationConsumer));
}
private static <Solution_, Score_ extends Score<Score_>> NodeNetwork buildNodeNetwork(Solution_ workingSolution,
ConsistencyTracker<Solution_> consistencyTracker, Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet,
AbstractScoreInliner<Score_> scoreInliner,
Consumer<String> nodeNetworkVisualizationConsumer) {
var buildHelper = new ConstraintNodeBuildHelper<>(consistencyTracker, constraintStreamSet, scoreInliner);
var declaredClassToNodeMap = new LinkedHashMap<Class<?>, List<AbstractForEachUniNode<?>>>();
var nodeList = buildHelper.buildNodeList(constraintStreamSet, buildHelper,
BavetAbstractConstraintStream::buildNode,
node -> {
if (!(node instanceof AbstractForEachUniNode<?> forEachUniNode)) {
return;
}
var forEachClass = forEachUniNode.getForEachClass();
var forEachUniNodeList =
declaredClassToNodeMap.computeIfAbsent(forEachClass, k -> new ArrayList<>(2));
if (forEachUniNodeList.size() == 3) {
// Each class can have at most three forEach nodes: one including everything, one including consistent + null vars, the last consistent + no null vars.
throw new IllegalStateException(
"Impossible state: For class (%s) there are already 3 nodes (%s), not adding another (%s)."
.formatted(forEachClass, forEachUniNodeList, forEachUniNode));
}
forEachUniNodeList.add(forEachUniNode);
});
if (nodeNetworkVisualizationConsumer != null) {
var constraintSet = scoreInliner.getConstraints();
var visualisation = NodeGraph
.of(workingSolution, nodeList, constraintSet, buildHelper::getNodeCreatingStream,
buildHelper::findParentNode)
.buildGraphvizDOT();
nodeNetworkVisualizationConsumer.accept(visualisation);
}
return AbstractNodeBuildHelper.buildNodeNetwork(nodeList, declaredClassToNodeMap);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetAbstractBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import static ai.timefold.solver.core.impl.score.stream.common.bi.InnerBiConstraintStream.createDefaultIndictedObjectsMapping;
import static ai.timefold.solver.core.impl.score.stream.common.bi.InnerBiConstraintStream.createDefaultJustificationMapping;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Function;
import java.util.function.ToIntBiFunction;
import java.util.function.ToLongBiFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.impl.bavet.bi.Group0Mapping1CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group0Mapping2CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group0Mapping3CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group0Mapping4CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group1Mapping0CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group1Mapping1CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group1Mapping2CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group1Mapping3CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group2Mapping0CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group2Mapping1CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group2Mapping2CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group3Mapping0CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group3Mapping1CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.bi.Group4Mapping0CollectorBiNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.bavet.tri.joiner.TriJoinerComber;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetAbstractQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetBiConcatQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetAbstractTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetBiConcatTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetJoinTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
import ai.timefold.solver.core.impl.score.stream.common.bi.BiConstraintBuilderImpl;
import ai.timefold.solver.core.impl.score.stream.common.bi.InnerBiConstraintStream;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NonNull;
public abstract class BavetAbstractBiConstraintStream<Solution_, A, B> extends BavetAbstractConstraintStream<Solution_>
implements InnerBiConstraintStream<A, B> {
protected BavetAbstractBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
protected BavetAbstractBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public @NonNull BavetAbstractBiConstraintStream<Solution_, A, B> filter(@NonNull BiPredicate<A, B> predicate) {
return shareAndAddChild(new BavetFilterBiConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// Join
// ************************************************************************
@Override
@SafeVarargs
public final <C> @NonNull TriConstraintStream<A, B, C> join(@NonNull UniConstraintStream<C> otherStream,
TriJoiner<A, B, C> @NonNull... joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, C>) otherStream;
var joinerComber = TriJoinerComber.comb(joiners);
var leftBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var joinStream = new BavetJoinTriConstraintStream<>(constraintFactory, leftBridge, rightBridge,
joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering());
return constraintFactory.share(joinStream, joinStream_ -> {
// Connect the bridges upstream, as it is an actual new join.
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final @NonNull <C> BiConstraintStream<A, B> ifExists(@NonNull UniConstraintStream<C> otherStream,
@NonNull TriJoiner<A, B, C> @NonNull... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final <C> @NonNull BiConstraintStream<A, B> ifNotExists(@NonNull UniConstraintStream<C> otherStream,
TriJoiner<A, B, C>... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <C> BiConstraintStream<A, B> ifExistsOrNot(boolean shouldExist, UniConstraintStream<C> otherStream,
TriJoiner<A, B, C>[] joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, C>) otherStream;
var joinerComber = TriJoinerComber.comb(joiners);
var parentBridgeC = other.shareAndAddChild(new BavetForeBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsBiConstraintStream<>(constraintFactory, this, parentBridgeC,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public @NonNull <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
@NonNull BiConstraintCollector<A, B, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collector, Group0Mapping1CollectorBiNode::new);
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
var stream = shareAndAddChild(new BavetUniGroupBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> @NonNull BiConstraintStream<ResultA_, ResultB_> groupBy(
@NonNull BiConstraintCollector<A, B, ResultContainerA_, ResultA_> collectorA,
@NonNull BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collectorA, collectorB, Group0Mapping2CollectorBiNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BavetBiGroupBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
@NonNull TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(@NonNull BiConstraintCollector<A, B, ResultContainerA_, ResultA_> collectorA,
@NonNull BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
@NonNull BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collectorA, collectorB, collectorC, Group0Mapping3CollectorBiNode::new);
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
var stream = shareAndAddChild(new BavetTriGroupBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
@NonNull QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull BiConstraintCollector<A, B, ResultContainerA_, ResultA_> collectorA,
@NonNull BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
@NonNull BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC,
@NonNull BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collectorA, collectorB, collectorC, collectorD,
Group0Mapping4CollectorBiNode::new);
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
var stream = shareAndAddChild(new BavetQuadGroupBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <GroupKey_> @NonNull UniConstraintStream<GroupKey_> groupBy(@NonNull BiFunction<A, B, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, Group1Mapping0CollectorBiNode::new);
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
@NonNull TriConstraintStream<GroupKey_, ResultB_, ResultC_>
groupBy(@NonNull BiFunction<A, B, GroupKey_> groupKeyMapping,
@NonNull BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
@NonNull BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, Group1Mapping2CollectorBiNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
@NonNull QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull BiFunction<A, B, GroupKey_> groupKeyMapping,
@NonNull BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
@NonNull BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC,
@NonNull BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, collectorD,
Group1Mapping3CollectorBiNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> @NonNull BiConstraintStream<GroupKey_, Result_> groupBy(
@NonNull BiFunction<A, B, GroupKey_> groupKeyMapping,
@NonNull BiConstraintCollector<A, B, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, collector, Group1Mapping1CollectorBiNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> @NonNull BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
@NonNull BiFunction<A, B, GroupKeyA_> groupKeyAMapping, @NonNull BiFunction<A, B, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
GroupNodeConstructor.twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorBiNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> @NonNull TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_>
groupBy(
@NonNull BiFunction<A, B, GroupKeyA_> groupKeyAMapping,
@NonNull BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
@NonNull BiConstraintCollector<A, B, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
GroupNodeConstructor.twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collector,
Group2Mapping1CollectorBiNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
@NonNull QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
@NonNull BiFunction<A, B, GroupKeyA_> groupKeyAMapping,
@NonNull BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
@NonNull BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC,
@NonNull BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collectorC, collectorD,
Group2Mapping2CollectorBiNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_> @NonNull TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
@NonNull BiFunction<A, B, GroupKeyA_> groupKeyAMapping, @NonNull BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
@NonNull BiFunction<A, B, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor =
GroupNodeConstructor.threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping,
Group3Mapping0CollectorBiNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
@NonNull QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(@NonNull BiFunction<A, B, GroupKeyA_> groupKeyAMapping,
@NonNull BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
@NonNull BiFunction<A, B, GroupKeyC_> groupKeyCMapping,
@NonNull BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping,
groupKeyCMapping, collectorD, Group3Mapping1CollectorBiNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
@NonNull QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(@NonNull BiFunction<A, B, GroupKeyA_> groupKeyAMapping,
@NonNull BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
@NonNull BiFunction<A, B, GroupKeyC_> groupKeyCMapping,
@NonNull BiFunction<A, B, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
GroupNodeConstructor.fourKeysGroupBy(
groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping,
Group4Mapping0CollectorBiNode::new);
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public @NonNull BiConstraintStream<A, B> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(ConstantLambdaUtils.biPickFirst(),
ConstantLambdaUtils.biPickSecond());
}
}
@Override
public @NonNull BiConstraintStream<A, B> concat(@NonNull UniConstraintStream<A> otherStream,
@NonNull Function<A, B> paddingFunction) {
var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
var leftBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var concatStream = new BavetUniConcatBiConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunction);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull BiConstraintStream<A, B> concat(@NonNull BiConstraintStream<A, B> otherStream) {
var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
var leftBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
var concatStream = new BavetBiConcatBiConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <C> TriConstraintStream<A, B, C> concat(@NonNull TriConstraintStream<A, B, C> otherStream,
@NonNull BiFunction<A, B, C> paddingFunction) {
var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
var leftBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, other);
var concatStream = new BavetBiConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunction);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public <C, D> @NonNull QuadConstraintStream<A, B, C, D> concat(@NonNull QuadConstraintStream<A, B, C, D> otherStream,
@NonNull BiFunction<A, B, C> paddingFunctionC, @NonNull BiFunction<A, B, D> paddingFunctionD) {
var other = (BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>) otherStream;
var leftBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, other);
var concatStream = new BavetBiConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunctionC,
paddingFunctionD);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public <ResultA_> @NonNull UniConstraintStream<ResultA_> map(@NonNull BiFunction<A, B, ResultA_> mapping) {
var stream = shareAndAddChild(new BavetUniMapBiConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_> @NonNull BiConstraintStream<ResultA_, ResultB_> map(
@NonNull BiFunction<A, B, ResultA_> mappingA,
@NonNull BiFunction<A, B, ResultB_> mappingB) {
var stream = shareAndAddChild(new BavetBiMapBiConstraintStream<>(constraintFactory, this, mappingA, mappingB));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_> @NonNull TriConstraintStream<ResultA_, ResultB_, ResultC_>
map(@NonNull BiFunction<A, B, ResultA_> mappingA, @NonNull BiFunction<A, B, ResultB_> mappingB,
@NonNull BiFunction<A, B, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapBiConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC, false));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_, ResultD_> @NonNull QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_> map(
@NonNull BiFunction<A, B, ResultA_> mappingA, @NonNull BiFunction<A, B, ResultB_> mappingB,
@NonNull BiFunction<A, B, ResultC_> mappingC,
@NonNull BiFunction<A, B, ResultD_> mappingD) {
var stream = shareAndAddChild(new BavetQuadMapBiConstraintStream<>(constraintFactory, this, mappingA, mappingB,
mappingC, mappingD, false));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultB_> @NonNull BiConstraintStream<A, ResultB_>
flattenLast(@NonNull Function<B, @NonNull Iterable<ResultB_>> mapping) {
var stream = shareAndAddChild(new BavetFlattenLastBiConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
// ************************************************************************
// Other operations
// ************************************************************************
@Override
public <ResultC_> @NonNull TriConstraintStream<A, B, ResultC_> expand(@NonNull BiFunction<A, B, ResultC_> mapping) {
var stream = shareAndAddChild(
new BavetTriMapBiConstraintStream<>(constraintFactory, this,
ConstantLambdaUtils.biPickFirst(),
ConstantLambdaUtils.biPickSecond(), mapping, true));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultC_, ResultD_> @NonNull QuadConstraintStream<A, B, ResultC_, ResultD_> expand(
@NonNull BiFunction<A, B, ResultC_> mappingC,
@NonNull BiFunction<A, B, ResultD_> mappingD) {
var stream = shareAndAddChild(new BavetQuadMapBiConstraintStream<>(constraintFactory, this,
ConstantLambdaUtils.biPickFirst(),
ConstantLambdaUtils.biPickSecond(), mappingC, mappingD, true));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
ToIntBiFunction<A, B> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringBiConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, scoreImpactType, constraintWeight);
}
private <Score_ extends Score<Score_>> BiConstraintBuilderImpl<A, B, Score_> newTerminator(
BavetScoringConstraintStream<Solution_> stream, ScoreImpactType impactType, Score_ constraintWeight) {
return new BiConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintDescription, constraintGroup, constraintWeight_, impactType_,
justificationMapping, indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName,
constraintDescription, constraintGroup, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
ToLongBiFunction<A, B> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringBiConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, scoreImpactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
BiFunction<A, B, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringBiConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, scoreImpactType, constraintWeight);
}
@Override
protected final TriFunction<A, B, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return createDefaultJustificationMapping();
}
@Override
protected final BiFunction<A, B, Collection<?>> getDefaultIndictedObjectsMapping() {
return createDefaultIndictedObjectsMapping();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetBiConcatBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.ConcatBiBiNode;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
public final class BavetBiConcatBiConstraintStream<Solution_, A, B> extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final ConcatNodeConstructor<A, B> nodeConstructor;
public BavetBiConcatBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatBiBiNode::new;
}
@Override
public boolean guaranteesDistinct() {
return false; // The two parents could have the same source; guarantee impossible.
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetBiConcatBiConstraintStream<?, ?, ?> other = (BavetBiConcatBiConstraintStream<?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "BiConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B> {
AbstractConcatNode<?, ?, ?> apply(TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int leftCloneStoreIndex,
int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetBiGroupBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiGroupBiConstraintStream<Solution_, A, B, NewA, NewB>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetBiGroupBiConstraintStream<?, ?, ?, ?, ?>) 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/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetBiMapBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.MapBiToBiNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiMapBiConstraintStream<Solution_, A, B, NewA, NewB>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BiFunction<A, B, NewA> mappingFunctionA;
private final BiFunction<A, B, NewB> mappingFunctionB;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiMapBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, NewA> mappingFunctionA,
BiFunction<A, B, NewB> mappingFunctionB) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapBiToBiNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetBiMapBiConstraintStream<?, ?, ?, ?, ?> that = (BavetBiMapBiConstraintStream<?, ?, ?, ?, ?>) 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);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetFilterBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.api.score.Score;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
final class BavetFilterBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BiPredicate<A, B> predicate;
public BavetFilterBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
BiPredicate<A, B> predicate) {
super(constraintFactory, parent);
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
buildHelper.<BiTuple<A, B>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> TupleLifecycle.conditionally(tupleLifecycle, predicate));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterBiConstraintStream<?, ?, ?> other) {
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetFlattenLastBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.FlattenLastBiNode;
import ai.timefold.solver.core.impl.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetFlattenLastBiConstraintStream<Solution_, A, B, NewB>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final Function<B, Iterable<NewB>> mappingFunction;
private BavetAftBridgeBiConstraintStream<Solution_, A, NewB> flattenLastStream;
public BavetFlattenLastBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
Function<B, Iterable<NewB>> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, A, NewB> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
AbstractFlattenLastNode<BiTuple<A, B>, BiTuple<A, NewB>, B, NewB> node = new FlattenLastBiNode<>(
inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetFlattenLastBiConstraintStream<?, ?, ?, ?> that = (BavetFlattenLastBiConstraintStream<?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "FlattenLast()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetIfExistsBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.IndexedIfExistsBiNode;
import ai.timefold.solver.core.impl.bavet.bi.UnindexedIfExistsBiNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.bavet.tri.joiner.DefaultTriJoiner;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetIfExistsConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
final class BavetIfExistsBiConstraintStream<Solution_, A, B, C>
extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements BavetIfExistsConstraintStream<Solution_> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parentAB;
private final BavetForeBridgeUniConstraintStream<Solution_, C> parentBridgeC;
private final boolean shouldExist;
private final DefaultTriJoiner<A, B, C> joiner;
private final TriPredicate<A, B, C> filtering;
public BavetIfExistsBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parentAB,
BavetForeBridgeUniConstraintStream<Solution_, C> parentBridgeC,
boolean shouldExist,
DefaultTriJoiner<A, B, C> joiner, TriPredicate<A, B, C> filtering) {
super(constraintFactory, parentAB.getRetrievalSemantics());
this.parentAB = parentAB;
this.parentBridgeC = parentBridgeC;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentAB.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentAB.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeC.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentAB.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<C> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsBiNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
downstream)
: new IndexedIfExistsBiNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
downstream, filtering))
: (filtering == null ? new UnindexedIfExistsBiNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()), downstream)
: new UnindexedIfExistsBiNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, this, parentBridgeC);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetIfExistsBiConstraintStream<?, ?, ?, ?> that = (BavetIfExistsBiConstraintStream<?, ?, ?, ?>) object;
/*
* 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 ifExists node comes from.
*/
return shouldExist == that.shouldExist && Objects.equals(parentAB,
that.parentAB) && Objects.equals(
parentBridgeC.getParent(), that.parentBridgeC.getParent())
&& Objects.equals(joiner,
that.joiner)
&& Objects.equals(
filtering, that.filtering);
}
@Override
public int hashCode() {
return Objects.hash(parentAB, parentBridgeC.getParent(), shouldExist, joiner, filtering);
}
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return parentAB;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return parentBridgeC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetJoinBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.api.score.Score;
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.bi.joiner.DefaultBiJoiner;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public final class BavetJoinBiConstraintStream<Solution_, A, B> extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements BavetJoinConstraintStream<Solution_> {
private final BavetForeBridgeUniConstraintStream<Solution_, A> leftParent;
private final BavetForeBridgeUniConstraintStream<Solution_, B> rightParent;
private final DefaultBiJoiner<A, B> joiner;
private final BiPredicate<A, B> filtering;
public BavetJoinBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, B> rightParent,
DefaultBiJoiner<A, B> joiner, BiPredicate<A, B> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<B> indexerFactory = new IndexerFactory<>(joiner);
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, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1)
: new UnindexedJoinBiNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinBiConstraintStream<?, ?, ?> other = (BavetJoinBiConstraintStream<?, ?, ?>) 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 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 BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetQuadGroupBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadGroupBiConstraintStream<Solution_, A, B, NewA, NewB, NewC, NewD>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadGroupBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetQuadGroupBiConstraintStream<?, ?, ?, ?, ?, ?, ?>) 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 "QuadGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetQuadMapBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.MapBiToQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadMapBiConstraintStream<Solution_, A, B, NewA, NewB, NewC, NewD>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BiFunction<A, B, NewA> mappingFunctionA;
private final BiFunction<A, B, NewB> mappingFunctionB;
private final BiFunction<A, B, NewC> mappingFunctionC;
private final BiFunction<A, B, NewD> mappingFunctionD;
private final boolean guaranteesDistinct;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadMapBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, NewA> mappingFunctionA,
BiFunction<A, B, NewB> mappingFunctionB, BiFunction<A, B, NewC> mappingFunctionC,
BiFunction<A, B, NewD> mappingFunctionD, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.mappingFunctionD = mappingFunctionD;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node =
new MapBiToQuadNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetQuadMapBiConstraintStream<?, ?, ?, ?, ?, ?, ?> that = (BavetQuadMapBiConstraintStream<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC,
that.mappingFunctionC)
&& Objects.equals(mappingFunctionD, that.mappingFunctionD);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "QuadMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetScoringBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import static ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream.impactWithConstraintMatchNoJustifications;
import java.math.BigDecimal;
import java.util.function.BiFunction;
import java.util.function.ToIntBiFunction;
import java.util.function.ToLongBiFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.common.inliner.ConstraintMatchSupplier;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class BavetScoringBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements BavetScoringConstraintStream<Solution_> {
private final ToIntBiFunction<A, B> intMatchWeigher;
private final ToLongBiFunction<A, B> longMatchWeigher;
private final BiFunction<A, B, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, ToIntBiFunction<A, B> intMatchWeigher) {
this(constraintFactory, parent, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, ToLongBiFunction<A, B> longMatchWeigher) {
this(constraintFactory, parent, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, ToIntBiFunction<A, B> intMatchWeigher,
ToLongBiFunction<A, B> longMatchWeigher, BiFunction<A, B, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent);
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
var scoreImpacter = buildScoreImpacter(buildHelper.getScoreInliner().getConstraintMatchPolicy());
var weightedScoreImpacter = buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint);
var scorer = new BiScorer<>(weightedScoreImpacter, scoreImpacter,
buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
private TriFunction<WeightedScoreImpacter<?, ?>, A, B, UndoScoreImpacter>
buildScoreImpacter(ConstraintMatchPolicy constraintMatchPolicy) {
return switch (constraintMatchPolicy) {
case DISABLED -> buildScoreImpacter();
case ENABLED -> buildScoreImpacterWithConstraintMatch();
case ENABLED_WITHOUT_JUSTIFICATIONS -> buildScoreImpacterWithConstraintMatchNoJustifications();
};
}
private TriFunction<WeightedScoreImpacter<?, ?>, A, B, UndoScoreImpacter> buildScoreImpacter() {
if (intMatchWeigher != null) {
return (impacter, a, b) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b);
return impacter.impactScore(matchWeight, null);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b);
return impacter.impactScore(matchWeight, null);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b);
return impacter.impactScore(matchWeight, null);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private TriFunction<WeightedScoreImpacter<?, ?>, A, B, UndoScoreImpacter> buildScoreImpacterWithConstraintMatch() {
if (intMatchWeigher != null) {
return (impacter, a, b) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b);
return impactWithConstraintMatch(impacter, matchWeight, a, b);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b);
return impactWithConstraintMatch(impacter, matchWeight, a, b);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b);
return impactWithConstraintMatch(impacter, matchWeight, a, b);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private static <A, B, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight, A a, B b) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight, A a, B b) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight, A a, B b) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private TriFunction<WeightedScoreImpacter<?, ?>, A, B, UndoScoreImpacter>
buildScoreImpacterWithConstraintMatchNoJustifications() {
if (intMatchWeigher != null) {
return (impacter, a, b) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintRef() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetTriGroupBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriGroupBiConstraintStream<Solution_, A, B, NewA, NewB, NewC>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriGroupBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetTriGroupBiConstraintStream<?, ?, ?, ?, ?, ?>) 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 "TriGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetTriMapBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.MapBiToTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriMapBiConstraintStream<Solution_, A, B, NewA, NewB, NewC>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BiFunction<A, B, NewA> mappingFunctionA;
private final BiFunction<A, B, NewB> mappingFunctionB;
private final BiFunction<A, B, NewC> mappingFunctionC;
private final boolean guaranteesDistinct;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriMapBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, NewA> mappingFunctionA,
BiFunction<A, B, NewB> mappingFunctionB, BiFunction<A, B, NewC> mappingFunctionC, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapBiToTriNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetTriMapBiConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetTriMapBiConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC, that.mappingFunctionC);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "TriMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetUniConcatBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.ConcatBiUniNode;
import ai.timefold.solver.core.impl.bavet.bi.ConcatUniBiNode;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public final class BavetUniConcatBiConstraintStream<Solution_, A, B> extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final Function<A, B> paddingFunction;
private final ConcatNodeConstructor<A, B> nodeConstructor;
public BavetUniConcatBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent,
Function<A, B> paddingFunction) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunction = paddingFunction;
this.nodeConstructor = ConcatUniBiNode::new;
}
public BavetUniConcatBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, A> rightParent,
Function<A, B> paddingFunction) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunction = paddingFunction;
this.nodeConstructor = ConcatBiUniNode::new;
}
@Override
public boolean guaranteesDistinct() {
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
var rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node =
nodeConstructor.apply(paddingFunction, downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
var other = (BavetUniConcatBiConstraintStream<?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "UniConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B> {
AbstractConcatNode<?, ?, ?> apply(Function<A, B> paddingFunction,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetUniGroupBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniGroupBiConstraintStream<Solution_, A, B, NewA>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniGroupBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetUniGroupBiConstraintStream<?, ?, ?, ?>) 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 "UniGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BavetUniMapBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.MapBiToUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniMapBiConstraintStream<Solution_, A, B, NewA>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BiFunction<A, B, NewA> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniMapBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, NewA> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapBiToUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetUniMapBiConstraintStream<?, ?, ?, ?> that = (BavetUniMapBiConstraintStream<?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/bi/BiScorer.java | package ai.timefold.solver.core.impl.score.stream.bavet.bi;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractScorer;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class BiScorer<A, B> extends AbstractScorer<BiTuple<A, B>> {
private final TriFunction<WeightedScoreImpacter<?, ?>, A, B, UndoScoreImpacter> scoreImpacter;
public BiScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter,
TriFunction<WeightedScoreImpacter<?, ?>, A, B, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(weightedScoreImpacter, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(BiTuple<A, B> tuple) {
try {
return scoreImpacter.apply(weightedScoreImpacter, tuple.factA, tuple.factB);
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/BavetConcatConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
public interface BavetConcatConstraintStream<Solution_>
extends BavetConstraintStreamBinaryOperation<Solution_>, TupleSource {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/BavetConstraintStreamBinaryOperation.java | package ai.timefold.solver.core.impl.score.stream.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.BavetStreamBinaryOperation;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public interface BavetConstraintStreamBinaryOperation<Solution_>
extends BavetStreamBinaryOperation<BavetAbstractConstraintStream<Solution_>> {
/**
* @return An instance of {@link BavetForeBridgeUniConstraintStream}.
*/
BavetAbstractConstraintStream<Solution_> getLeftParent();
/**
* @return An instance of {@link BavetForeBridgeUniConstraintStream}.
*/
BavetAbstractConstraintStream<Solution_> getRightParent();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/BavetIfExistsConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common;
public interface BavetIfExistsConstraintStream<Solution_> extends BavetConstraintStreamBinaryOperation<Solution_> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/BavetJoinConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
public interface BavetJoinConstraintStream<Solution_>
extends BavetConstraintStreamBinaryOperation<Solution_>, TupleSource {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/BavetScoringConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common;
import java.math.BigDecimal;
import java.util.Set;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
import ai.timefold.solver.core.impl.score.stream.common.inliner.ConstraintMatchSupplier;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
public interface BavetScoringConstraintStream<Solution_> {
void setConstraint(BavetConstraint<Solution_> constraint);
void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet);
static <Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatchNoJustifications(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight) {
var constraintMatchSupplier = ConstraintMatchSupplier.<Score_> empty();
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
static <Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatchNoJustifications(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight) {
var constraintMatchSupplier = ConstraintMatchSupplier.<Score_> empty();
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
static <Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatchNoJustifications(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight) {
var constraintMatchSupplier = ConstraintMatchSupplier.<Score_> empty();
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/ConstraintNodeBuildHelper.java | package ai.timefold.solver.core.impl.score.stream.bavet.common;
import java.util.HashMap;
import java.util.Map;
import java.util.Set;
import java.util.function.Predicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractNodeBuildHelper;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.ConsistencyTracker;
import ai.timefold.solver.core.impl.score.stream.common.ForEachFilteringCriteria;
import ai.timefold.solver.core.impl.score.stream.common.inliner.AbstractScoreInliner;
public final class ConstraintNodeBuildHelper<Solution_, Score_ extends Score<Score_>>
extends AbstractNodeBuildHelper<BavetAbstractConstraintStream<Solution_>> {
private final AbstractScoreInliner<Score_> scoreInliner;
private final ConsistencyTracker<Solution_> consistencyTracker;
private final Map<EntityDescriptor<?>, Map<ForEachFilteringCriteria, Predicate<Object>>> entityDescriptorToForEachCriteriaToPredicateMap;
public ConstraintNodeBuildHelper(ConsistencyTracker<Solution_> consistencyTracker,
Set<BavetAbstractConstraintStream<Solution_>> activeStreamSet,
AbstractScoreInliner<Score_> scoreInliner) {
super(activeStreamSet);
this.consistencyTracker = consistencyTracker;
this.scoreInliner = scoreInliner;
this.entityDescriptorToForEachCriteriaToPredicateMap = new HashMap<>();
}
public AbstractScoreInliner<Score_> getScoreInliner() {
return scoreInliner;
}
public <A> Predicate<A> getForEachPredicateForEntityDescriptorAndCriteria(EntityDescriptor<?> entityDescriptor,
ForEachFilteringCriteria criteria) {
var predicateMap =
entityDescriptorToForEachCriteriaToPredicateMap.computeIfAbsent(entityDescriptor, ignored -> new HashMap<>());
return (Predicate<A>) predicateMap.computeIfAbsent(criteria,
ignored -> criteria.getFilterForEntityDescriptor(consistencyTracker, entityDescriptor));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetAftBridgeBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
public final class BavetAftBridgeBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements TupleSource {
public BavetAftBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeBiConstraintStream<?, ?, ?> that = (BavetAftBridgeBiConstraintStream<?, ?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return 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/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetAftBridgeQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetAbstractQuadConstraintStream;
public final class BavetAftBridgeQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements TupleSource {
public BavetAftBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeQuadConstraintStream<?, ?, ?, ?, ?> that = (BavetAftBridgeQuadConstraintStream<?, ?, ?, ?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return 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/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetAftBridgeTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetAbstractTriConstraintStream;
public final class BavetAftBridgeTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements TupleSource {
public BavetAftBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeTriConstraintStream<?, ?, ?, ?> that = (BavetAftBridgeTriConstraintStream<?, ?, ?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return 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/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetAftBridgeUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.TupleSource;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetAbstractUniConstraintStream;
public final class BavetAftBridgeUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements TupleSource {
public BavetAftBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeUniConstraintStream<?, ?> that = (BavetAftBridgeUniConstraintStream<?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return 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/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetForeBridgeBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
public final class BavetForeBridgeBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
public BavetForeBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetForeBridgeQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetAbstractQuadConstraintStream;
public final class BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
public BavetForeBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetForeBridgeTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetAbstractTriConstraintStream;
public final class BavetForeBridgeTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
public BavetForeBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/BavetForeBridgeUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.common.bridge;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetAbstractUniConstraintStream;
public final class BavetForeBridgeUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
public BavetForeBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> 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/score/stream/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/common/bridge/package-info.java | /**
* Contains 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.score.stream.bavet.common.bridge; |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetAbstractQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import static ai.timefold.solver.core.impl.score.stream.common.quad.InnerQuadConstraintStream.createDefaultIndictedObjectsMapping;
import static ai.timefold.solver.core.impl.score.stream.common.quad.InnerQuadConstraintStream.createDefaultJustificationMapping;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.bavet.penta.joiner.PentaJoinerComber;
import ai.timefold.solver.core.impl.bavet.quad.Group0Mapping1CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group0Mapping2CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group0Mapping3CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group0Mapping4CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group1Mapping0CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group1Mapping1CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group1Mapping2CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group1Mapping3CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group2Mapping0CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group2Mapping1CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group2Mapping2CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group3Mapping0CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group3Mapping1CollectorQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.Group4Mapping0CollectorQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetAbstractTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
import ai.timefold.solver.core.impl.score.stream.common.quad.InnerQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.quad.QuadConstraintBuilderImpl;
import org.jspecify.annotations.NonNull;
public abstract class BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractConstraintStream<Solution_>
implements InnerQuadConstraintStream<A, B, C, D> {
protected BavetAbstractQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
protected BavetAbstractQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public @NonNull BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
filter(@NonNull QuadPredicate<A, B, C, D> predicate) {
return shareAndAddChild(new BavetFilterQuadConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final <E> @NonNull QuadConstraintStream<A, B, C, D> ifExists(@NonNull UniConstraintStream<E> otherStream,
PentaJoiner<A, B, C, D, E>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final @NonNull <E> QuadConstraintStream<A, B, C, D> ifNotExists(@NonNull UniConstraintStream<E> otherStream,
@NonNull PentaJoiner<A, B, C, D, E> @NonNull... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <E> QuadConstraintStream<A, B, C, D> ifExistsOrNot(boolean shouldExist,
UniConstraintStream<E> otherStream, PentaJoiner<A, B, C, D, E>[] joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, E>) otherStream;
var joinerComber = PentaJoinerComber.comb(joiners);
var parentBridgeD = other.shareAndAddChild(new BavetForeBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsQuadConstraintStream<>(constraintFactory, this, parentBridgeD,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public @NonNull <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collector, Group0Mapping1CollectorQuadNode::new);
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
var stream = shareAndAddChild(new BavetUniGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collectorA, collectorB, Group0Mapping2CollectorQuadNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BavetBiGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collectorA, collectorB, collectorC, Group0Mapping3CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
var stream = shareAndAddChild(new BavetTriGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.zeroKeysGroupBy(collectorA, collectorB, collectorC, collectorD,
Group0Mapping4CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
var stream = shareAndAddChild(new BavetQuadGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <GroupKey_> UniConstraintStream<GroupKey_>
groupBy(@NonNull QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, Group1Mapping0CollectorQuadNode::new);
return buildUniGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_>
groupBy(@NonNull QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, collectorB, collectorC,
Group1Mapping2CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, collectorD,
Group1Mapping3CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
@NonNull QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor =
GroupNodeConstructor.oneKeyGroupBy(groupKeyMapping, collector, Group1Mapping1CollectorQuadNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
@NonNull QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
GroupNodeConstructor.twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorQuadNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_>
groupBy(
@NonNull QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
GroupNodeConstructor.twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collector,
Group2Mapping1CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
@NonNull QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collectorC, collectorD,
Group2Mapping2CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
@NonNull QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor =
GroupNodeConstructor.threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping,
Group3Mapping0CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(@NonNull QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping,
@NonNull QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor =
GroupNodeConstructor.threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, collectorD,
Group3Mapping1CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(@NonNull QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping,
@NonNull QuadFunction<A, B, C, D, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
GroupNodeConstructor.fourKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping,
Group4Mapping0CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public @NonNull QuadConstraintStream<A, B, C, D> concat(@NonNull UniConstraintStream<A> otherStream,
@NonNull Function<A, B> paddingFunctionB,
@NonNull Function<A, C> paddingFunctionC, @NonNull Function<A, D> paddingFunctionD) {
var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var concatStream =
new BavetUniConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunctionB,
paddingFunctionC, paddingFunctionD);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull QuadConstraintStream<A, B, C, D> concat(@NonNull BiConstraintStream<A, B> otherStream,
@NonNull BiFunction<A, B, C> paddingFunctionC,
@NonNull BiFunction<A, B, D> paddingFunctionD) {
var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
var concatStream = new BavetBiConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunctionC,
paddingFunctionD);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull QuadConstraintStream<A, B, C, D> concat(@NonNull TriConstraintStream<A, B, C> otherStream,
@NonNull TriFunction<A, B, C, D> paddingFunction) {
var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, other);
var concatStream =
new BavetTriConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunction);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull QuadConstraintStream<A, B, C, D> concat(@NonNull QuadConstraintStream<A, B, C, D> otherStream) {
var other = (BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, other);
var concatStream = new BavetQuadConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <ResultA_> UniConstraintStream<ResultA_> map(@NonNull QuadFunction<A, B, C, D, ResultA_> mapping) {
var stream = shareAndAddChild(new BavetUniMapQuadConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_> BiConstraintStream<ResultA_, ResultB_> map(
@NonNull QuadFunction<A, B, C, D, ResultA_> mappingA,
@NonNull QuadFunction<A, B, C, D, ResultB_> mappingB) {
var stream = shareAndAddChild(new BavetBiMapQuadConstraintStream<>(constraintFactory, this, mappingA, mappingB));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_, ResultC_> TriConstraintStream<ResultA_, ResultB_, ResultC_> map(
@NonNull QuadFunction<A, B, C, D, ResultA_> mappingA, @NonNull QuadFunction<A, B, C, D, ResultB_> mappingB,
@NonNull QuadFunction<A, B, C, D, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapQuadConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_> map(
@NonNull QuadFunction<A, B, C, D, ResultA_> mappingA, @NonNull QuadFunction<A, B, C, D, ResultB_> mappingB,
@NonNull QuadFunction<A, B, C, D, ResultC_> mappingC, @NonNull QuadFunction<A, B, C, D, ResultD_> mappingD) {
var stream = shareAndAddChild(
new BavetQuadMapQuadConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC, mappingD));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultD_> QuadConstraintStream<A, B, C, ResultD_>
flattenLast(@NonNull Function<D, Iterable<ResultD_>> mapping) {
var stream = shareAndAddChild(new BavetFlattenLastQuadConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> QuadConstraintBuilderImpl<A, B, C, D, Score_> newTerminator(
BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new QuadConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintDescription, constraintGroup, constraintWeight_, impactType_,
justificationMapping, indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName,
constraintDescription, constraintGroup, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final PentaFunction<A, B, C, D, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return createDefaultJustificationMapping();
}
@Override
protected final QuadFunction<A, B, C, D, Collection<?>> getDefaultIndictedObjectsMapping() {
return createDefaultIndictedObjectsMapping();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetBiConcatQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.quad.ConcatBiQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.ConcatQuadBiNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
public final class BavetBiConcatQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final BiFunction<A, B, C> paddingFunctionC;
private final BiFunction<A, B, D> paddingFunctionD;
private final ConcatNodeConstructor<A, B, C, D> nodeConstructor;
public BavetBiConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent,
BiFunction<A, B, C> paddingFunctionC, BiFunction<A, B, D> paddingFunctionD) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
this.nodeConstructor = ConcatBiQuadNode::new;
}
public BavetBiConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent,
BiFunction<A, B, C> paddingFunctionC, BiFunction<A, B, D> paddingFunctionD) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
this.nodeConstructor = ConcatQuadBiNode::new;
}
@Override
public boolean guaranteesDistinct() {
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
var rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(paddingFunctionC, paddingFunctionD, downstream, leftCloneStoreIndex,
rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
var other = (BavetBiConcatQuadConstraintStream<?, ?, ?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "BiConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C, D> {
AbstractConcatNode<?, ?, ?> apply(BiFunction<A, B, C> paddingFunctionC, BiFunction<A, B, D> paddingFunctionD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetBiGroupQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiGroupQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetBiGroupQuadConstraintStream<?, ?, ?, ?, ?, ?, ?>) 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/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetBiMapQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.quad.MapQuadToBiNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiMapQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapQuadToBiNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetBiMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?> that = (BavetBiMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?>) 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);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetFilterQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
final class BavetFilterQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadPredicate<A, B, C, D> predicate;
public BavetFilterQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadPredicate<A, B, C, D> predicate) {
super(constraintFactory, parent);
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
buildHelper.<QuadTuple<A, B, C, D>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> TupleLifecycle.conditionally(tupleLifecycle, predicate));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterQuadConstraintStream<?, ?, ?, ?, ?> other) {
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetFlattenLastQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.quad.FlattenLastQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetFlattenLastQuadConstraintStream<Solution_, A, B, C, D, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final Function<D, Iterable<NewD>> mappingFunction;
private BavetAftBridgeQuadConstraintStream<Solution_, A, B, C, NewD> flattenLastStream;
public BavetFlattenLastQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
Function<D, Iterable<NewD>> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, A, B, C, NewD> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
var node = new FlattenLastQuadNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetFlattenLastQuadConstraintStream<?, ?, ?, ?, ?, ?> that =
(BavetFlattenLastQuadConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "FlattenLast()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetIfExistsQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.penta.joiner.DefaultPentaJoiner;
import ai.timefold.solver.core.impl.bavet.quad.IndexedIfExistsQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.UnindexedIfExistsQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetIfExistsConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
final class BavetIfExistsQuadConstraintStream<Solution_, A, B, C, D, E>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetIfExistsConstraintStream<Solution_> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD;
private final BavetForeBridgeUniConstraintStream<Solution_, E> parentBridgeE;
private final boolean shouldExist;
private final DefaultPentaJoiner<A, B, C, D, E> joiner;
private final PentaPredicate<A, B, C, D, E> filtering;
public BavetIfExistsQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD,
BavetForeBridgeUniConstraintStream<Solution_, E> parentBridgeE,
boolean shouldExist,
DefaultPentaJoiner<A, B, C, D, E> joiner, PentaPredicate<A, B, C, D, E> filtering) {
super(constraintFactory, parentABCD.getRetrievalSemantics());
this.parentABCD = parentABCD;
this.parentBridgeE = parentBridgeE;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABCD.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABCD.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeE.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABCD.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<E> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsQuadNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream)
: new IndexedIfExistsQuadNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, filtering))
: (filtering == null ? new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()), downstream)
: new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, this, parentBridgeE);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetIfExistsQuadConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetIfExistsQuadConstraintStream<?, ?, ?, ?, ?, ?>) object;
/*
* 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 ifExists node comes from.
*/
return shouldExist == that.shouldExist && Objects.equals(parentABCD,
that.parentABCD) && Objects.equals(
parentBridgeE.getParent(), that.parentBridgeE.getParent())
&& Objects.equals(joiner,
that.joiner)
&& Objects.equals(
filtering, that.filtering);
}
@Override
public int hashCode() {
return Objects.hash(parentABCD, parentBridgeE.getParent(), shouldExist, joiner, filtering);
}
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return parentABCD;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return parentBridgeE;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetJoinQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.quad.IndexedJoinQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.UnindexedJoinQuadNode;
import ai.timefold.solver.core.impl.bavet.quad.joiner.DefaultQuadJoiner;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public final class BavetJoinQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetJoinConstraintStream<Solution_> {
private final BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent;
private final BavetForeBridgeUniConstraintStream<Solution_, D> rightParent;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetJoinQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, D> rightParent,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<D> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? new IndexedJoinQuadNode<>(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, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1)
: new UnindexedJoinQuadNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetJoinQuadConstraintStream<?, ?, ?, ?, ?>) 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 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 "QuadJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetQuadConcatQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.quad.ConcatQuadQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
public final class BavetQuadConcatQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final ConcatNodeConstructor<A, B, C, D> nodeConstructor;
public BavetQuadConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatQuadQuadNode::new;
}
@Override
public boolean guaranteesDistinct() {
return false; // The two parents could have the same source; guarantee impossible.
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetQuadConcatQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetQuadConcatQuadConstraintStream<?, ?, ?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "QuadConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C, D> {
AbstractConcatNode<?, ?, ?> apply(TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetQuadGroupQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadGroupQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetQuadGroupQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?, ?>) 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 "QuadGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetQuadMapQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.quad.MapQuadToQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadMapQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private final QuadFunction<A, B, C, D, NewC> mappingFunctionC;
private final QuadFunction<A, B, C, D, NewD> mappingFunctionD;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB, QuadFunction<A, B, C, D, NewC> mappingFunctionC,
QuadFunction<A, B, C, D, NewD> mappingFunctionD) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.mappingFunctionD = mappingFunctionD;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node =
new MapQuadToQuadNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetQuadMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?, ?> that =
(BavetQuadMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC,
that.mappingFunctionC)
&& Objects.equals(mappingFunctionD, that.mappingFunctionD);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "QuadMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetScoringQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import static ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream.impactWithConstraintMatchNoJustifications;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.common.inliner.ConstraintMatchSupplier;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class BavetScoringQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetScoringConstraintStream<Solution_> {
private final ToIntQuadFunction<A, B, C, D> intMatchWeigher;
private final ToLongQuadFunction<A, B, C, D> longMatchWeigher;
private final QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, ToIntQuadFunction<A, B, C, D> intMatchWeigher) {
this(constraintFactory, parent, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, ToLongQuadFunction<A, B, C, D> longMatchWeigher) {
this(constraintFactory, parent, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, ToIntQuadFunction<A, B, C, D> intMatchWeigher,
ToLongQuadFunction<A, B, C, D> longMatchWeigher, QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent);
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
var scoreImpacter = buildScoreImpacter(buildHelper.getScoreInliner().getConstraintMatchPolicy());
var weightedScoreImpacter = buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint);
var scorer = new QuadScorer<>(weightedScoreImpacter, scoreImpacter,
buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
private PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter>
buildScoreImpacter(ConstraintMatchPolicy constraintMatchPolicy) {
return switch (constraintMatchPolicy) {
case DISABLED -> buildScoreImpacter();
case ENABLED -> buildScoreImpacterWithConstraintMatch();
case ENABLED_WITHOUT_JUSTIFICATIONS -> buildScoreImpacterWithConstraintMatchNoJustifications();
};
}
private PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> buildScoreImpacter() {
if (intMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c, d);
return impacter.impactScore(matchWeight, null);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c, d);
return impacter.impactScore(matchWeight, null);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c, d);
return impacter.impactScore(matchWeight, null);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> buildScoreImpacterWithConstraintMatch() {
if (intMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c, d);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c, d);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c, d);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c, d);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c, d);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c, d);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private static <A, B, C, D, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight, A a, B b, C c, D d) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, D, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c, d);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, D, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight, A a, B b, C c, D d) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, D, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c, d);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, D, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight, A a, B b, C c, D d) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, D, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c, d);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter>
buildScoreImpacterWithConstraintMatchNoJustifications() {
if (intMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c, d);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c, d);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c, d);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintRef() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetTriConcatQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.quad.ConcatQuadTriNode;
import ai.timefold.solver.core.impl.bavet.quad.ConcatTriQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
public final class BavetTriConcatQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final TriFunction<A, B, C, D> paddingFunctionD;
private final ConcatNodeConstructor<A, B, C, D> nodeConstructor;
public BavetTriConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent,
TriFunction<A, B, C, D> paddingFunctionD) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionD = paddingFunctionD;
this.nodeConstructor = ConcatTriQuadNode::new;
}
public BavetTriConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent,
TriFunction<A, B, C, D> paddingFunctionD) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionD = paddingFunctionD;
this.nodeConstructor = ConcatQuadTriNode::new;
}
@Override
public boolean guaranteesDistinct() {
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
var rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node =
nodeConstructor.apply(paddingFunctionD, downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
var other = (BavetTriConcatQuadConstraintStream<?, ?, ?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "TriConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C, D> {
AbstractConcatNode<?, ?, ?> apply(TriFunction<A, B, C, D> paddingFunction,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetTriGroupQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriGroupQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetTriGroupQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) 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 "TriGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetTriMapQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.quad.MapQuadToTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriMapQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private final QuadFunction<A, B, C, D, NewC> mappingFunctionC;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB, QuadFunction<A, B, C, D, NewC> mappingFunctionC) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapQuadToTriNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetTriMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?> that =
(BavetTriMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB) && Objects.equals(mappingFunctionC, that.mappingFunctionC);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "TriMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetUniConcatQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.quad.ConcatQuadUniNode;
import ai.timefold.solver.core.impl.bavet.quad.ConcatUniQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public final class BavetUniConcatQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final Function<A, B> paddingFunctionB;
private final Function<A, C> paddingFunctionC;
private final Function<A, D> paddingFunctionD;
private final ConcatNodeConstructor<A, B, C, D> nodeConstructor;
public BavetUniConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent,
Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC, Function<A, D> paddingFunctionD) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
this.nodeConstructor = ConcatUniQuadNode::new;
}
public BavetUniConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, A> rightParent,
Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC, Function<A, D> paddingFunctionD) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
this.nodeConstructor = ConcatQuadUniNode::new;
}
@Override
public boolean guaranteesDistinct() {
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
var rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(paddingFunctionB, paddingFunctionC, paddingFunctionD, downstream, leftCloneStoreIndex,
rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
var other = (BavetUniConcatQuadConstraintStream<?, ?, ?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "UniConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C, D> {
AbstractConcatNode<?, ?, ?> apply(
Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC, Function<A, D> paddingFunctionD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetUniGroupQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniGroupQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetUniGroupQuadConstraintStream<?, ?, ?, ?, ?, ?>) 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 "UniGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/BavetUniMapQuadConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.quad.MapQuadToUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniMapQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapQuadToUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetUniMapQuadConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetUniMapQuadConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/quad/QuadScorer.java | package ai.timefold.solver.core.impl.score.stream.bavet.quad;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractScorer;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class QuadScorer<A, B, C, D> extends AbstractScorer<QuadTuple<A, B, C, D>> {
private final PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> scoreImpacter;
public QuadScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter,
PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(weightedScoreImpacter, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(QuadTuple<A, B, C, D> tuple) {
try {
return scoreImpacter.apply(weightedScoreImpacter, tuple.factA, tuple.factB, tuple.factC, tuple.factD);
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetAbstractTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.fourKeysGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.oneKeyGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.threeKeysGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.twoKeysGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.zeroKeysGroupBy;
import static ai.timefold.solver.core.impl.score.stream.common.tri.InnerTriConstraintStream.createDefaultIndictedObjectsMapping;
import static ai.timefold.solver.core.impl.score.stream.common.tri.InnerTriConstraintStream.createDefaultJustificationMapping;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.bavet.quad.joiner.QuadJoinerComber;
import ai.timefold.solver.core.impl.bavet.tri.Group0Mapping1CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group0Mapping2CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group0Mapping3CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group0Mapping4CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group1Mapping0CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group1Mapping1CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group1Mapping2CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group1Mapping3CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group2Mapping0CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group2Mapping1CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group2Mapping2CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group3Mapping0CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group3Mapping1CollectorTriNode;
import ai.timefold.solver.core.impl.bavet.tri.Group4Mapping0CollectorTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetAbstractQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetJoinQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetTriConcatQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
import ai.timefold.solver.core.impl.score.stream.common.tri.InnerTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.tri.TriConstraintBuilderImpl;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NonNull;
public abstract class BavetAbstractTriConstraintStream<Solution_, A, B, C> extends BavetAbstractConstraintStream<Solution_>
implements InnerTriConstraintStream<A, B, C> {
protected BavetAbstractTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
protected BavetAbstractTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public @NonNull TriConstraintStream<A, B, C> filter(@NonNull TriPredicate<A, B, C> predicate) {
return shareAndAddChild(new BavetFilterTriConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// Join
// ************************************************************************
@Override
@SafeVarargs
public final <D> @NonNull QuadConstraintStream<A, B, C, D> join(@NonNull UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D> @NonNull... joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, D>) otherStream;
var joinerComber = QuadJoinerComber.comb(joiners);
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var joinStream = new BavetJoinQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge,
joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering());
return constraintFactory.share(joinStream, joinStream_ -> {
// Connect the bridges upstream, as it is an actual new join.
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final @NonNull <D> TriConstraintStream<A, B, C> ifExists(@NonNull UniConstraintStream<D> otherStream,
@NonNull QuadJoiner<A, B, C, D> @NonNull... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final @NonNull <D> TriConstraintStream<A, B, C> ifNotExists(@NonNull UniConstraintStream<D> otherStream,
@NonNull QuadJoiner<A, B, C, D> @NonNull... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <D> TriConstraintStream<A, B, C> ifExistsOrNot(boolean shouldExist, UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>[] joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, D>) otherStream;
var joinerComber = QuadJoinerComber.comb(joiners);
var parentBridgeD = other.shareAndAddChild(new BavetForeBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsTriConstraintStream<>(constraintFactory, this, parentBridgeD,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public @NonNull <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
@NonNull TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor =
zeroKeysGroupBy(collector, Group0Mapping1CollectorTriNode::new);
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA>
buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
var stream = shareAndAddChild(new BavetUniGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
@NonNull TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
@NonNull TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, Group0Mapping2CollectorTriNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BavetBiGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(@NonNull TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
@NonNull TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
@NonNull TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, Group0Mapping3CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
var stream = shareAndAddChild(new BavetTriGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
@NonNull TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
@NonNull TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
@NonNull TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, collectorD, Group0Mapping4CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
var stream = shareAndAddChild(new BavetQuadGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <GroupKey_> UniConstraintStream<GroupKey_>
groupBy(@NonNull TriFunction<A, B, C, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, Group1Mapping0CollectorTriNode::new);
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
@NonNull TriConstraintStream<GroupKey_, ResultB_, ResultC_>
groupBy(@NonNull TriFunction<A, B, C, GroupKey_> groupKeyMapping,
@NonNull TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
@NonNull TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, Group1Mapping2CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull TriFunction<A, B, C, GroupKey_> groupKeyMapping,
@NonNull TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
@NonNull TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
@NonNull TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, collectorD, Group1Mapping3CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
@NonNull TriFunction<A, B, C, GroupKey_> groupKeyMapping,
@NonNull TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collector, Group1Mapping1CollectorTriNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
@NonNull TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
@NonNull TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorTriNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_>
groupBy(
@NonNull TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
@NonNull TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
@NonNull TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collector, Group2Mapping1CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
@NonNull TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
@NonNull TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
@NonNull TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
@NonNull TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collectorC, collectorD, Group2Mapping2CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
@NonNull TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
@NonNull TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
@NonNull TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, Group3Mapping0CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(@NonNull TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
@NonNull TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
@NonNull TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping,
@NonNull TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, collectorD,
Group3Mapping1CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(@NonNull TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
@NonNull TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
@NonNull TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping,
@NonNull TriFunction<A, B, C, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
fourKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping,
Group4Mapping0CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public @NonNull TriConstraintStream<A, B, C> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(ConstantLambdaUtils.triPickFirst(),
ConstantLambdaUtils.triPickSecond(),
ConstantLambdaUtils.triPickThird());
}
}
@Override
public @NonNull TriConstraintStream<A, B, C> concat(@NonNull UniConstraintStream<A> otherStream,
@NonNull Function<A, B> paddingFunctionB,
@NonNull Function<A, C> paddingFunctionC) {
var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var concatStream = new BavetUniConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunctionB,
paddingFunctionC);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull TriConstraintStream<A, B, C> concat(@NonNull BiConstraintStream<A, B> otherStream,
@NonNull BiFunction<A, B, C> paddingFunction) {
var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
var concatStream = new BavetBiConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunction);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull TriConstraintStream<A, B, C> concat(@NonNull TriConstraintStream<A, B, C> otherStream) {
var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, other);
var concatStream = new BavetTriConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <D> QuadConstraintStream<A, B, C, D> concat(@NonNull QuadConstraintStream<A, B, C, D> otherStream,
@NonNull TriFunction<A, B, C, D> paddingFunction) {
var other = (BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, other);
var concatStream =
new BavetTriConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunction);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <ResultA_> UniConstraintStream<ResultA_> map(@NonNull TriFunction<A, B, C, ResultA_> mapping) {
var stream = shareAndAddChild(new BavetUniMapTriConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_> BiConstraintStream<ResultA_, ResultB_> map(
@NonNull TriFunction<A, B, C, ResultA_> mappingA,
@NonNull TriFunction<A, B, C, ResultB_> mappingB) {
var stream = shareAndAddChild(new BavetBiMapTriConstraintStream<>(constraintFactory, this, mappingA, mappingB));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_, ResultC_> TriConstraintStream<ResultA_, ResultB_, ResultC_> map(
@NonNull TriFunction<A, B, C, ResultA_> mappingA, @NonNull TriFunction<A, B, C, ResultB_> mappingB,
@NonNull TriFunction<A, B, C, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapTriConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_, ResultD_> @NonNull QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_> map(
@NonNull TriFunction<A, B, C, ResultA_> mappingA, @NonNull TriFunction<A, B, C, ResultB_> mappingB,
@NonNull TriFunction<A, B, C, ResultC_> mappingC, @NonNull TriFunction<A, B, C, ResultD_> mappingD) {
var stream = shareAndAddChild(new BavetQuadMapTriConstraintStream<>(constraintFactory, this, mappingA, mappingB,
mappingC, mappingD, false));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultC_> TriConstraintStream<A, B, ResultC_>
flattenLast(@NonNull Function<C, Iterable<ResultC_>> mapping) {
var stream = shareAndAddChild(new BavetFlattenLastTriConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Other operations
// ************************************************************************
@Override
public @NonNull <ResultD_> QuadConstraintStream<A, B, C, ResultD_> expand(@NonNull TriFunction<A, B, C, ResultD_> mapping) {
var stream = shareAndAddChild(new BavetQuadMapTriConstraintStream<>(constraintFactory, this,
ConstantLambdaUtils.triPickFirst(),
ConstantLambdaUtils.triPickSecond(),
ConstantLambdaUtils.triPickThird(), mapping, true));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> TriConstraintBuilderImpl<A, B, C, Score_>
newTerminator(BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new TriConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintDescription, constraintGroup, constraintWeight_, impactType_,
justificationMapping, indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName,
constraintDescription, constraintGroup, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final QuadFunction<A, B, C, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return createDefaultJustificationMapping();
}
@Override
protected final TriFunction<A, B, C, Collection<?>> getDefaultIndictedObjectsMapping() {
return createDefaultIndictedObjectsMapping();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetBiConcatTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.tri.ConcatBiTriNode;
import ai.timefold.solver.core.impl.bavet.tri.ConcatTriBiNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
public final class BavetBiConcatTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final BiFunction<A, B, C> paddingFunction;
private final ConcatNodeConstructor<A, B, C> nodeConstructor;
public BavetBiConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent,
BiFunction<A, B, C> paddingFunction) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunction = paddingFunction;
this.nodeConstructor = ConcatBiTriNode::new;
}
public BavetBiConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent,
BiFunction<A, B, C> paddingFunction) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunction = paddingFunction;
this.nodeConstructor = ConcatTriBiNode::new;
}
@Override
public boolean guaranteesDistinct() {
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
var rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node =
nodeConstructor.apply(paddingFunction, downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
var other = (BavetBiConcatTriConstraintStream<?, ?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "BiConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C> {
AbstractConcatNode<?, ?, ?> apply(BiFunction<A, B, C> paddingFunction,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetBiGroupTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiGroupTriConstraintStream<Solution_, A, B, C, NewA, NewB>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetBiGroupTriConstraintStream<?, ?, ?, ?, ?, ?>) 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/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetBiMapTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.tri.MapTriToBiNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiMapTriConstraintStream<Solution_, A, B, C, NewA, NewB>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapTriToBiNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetBiMapTriConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetBiMapTriConstraintStream<?, ?, ?, ?, ?, ?>) 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);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetFilterTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
final class BavetFilterTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriPredicate<A, B, C> predicate;
public BavetFilterTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriPredicate<A, B, C> predicate) {
super(constraintFactory, parent);
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
buildHelper.<TriTuple<A, B, C>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> TupleLifecycle.conditionally(tupleLifecycle, predicate));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterTriConstraintStream<?, ?, ?, ?> other) {
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetFlattenLastTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.tri.FlattenLastTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetFlattenLastTriConstraintStream<Solution_, A, B, C, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final Function<C, Iterable<NewC>> mappingFunction;
private BavetAftBridgeTriConstraintStream<Solution_, A, B, NewC> flattenLastStream;
public BavetFlattenLastTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
Function<C, Iterable<NewC>> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, A, B, NewC> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
var node = new FlattenLastTriNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetFlattenLastTriConstraintStream<?, ?, ?, ?, ?> that = (BavetFlattenLastTriConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "FlattenLast()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetIfExistsTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.quad.joiner.DefaultQuadJoiner;
import ai.timefold.solver.core.impl.bavet.tri.IndexedIfExistsTriNode;
import ai.timefold.solver.core.impl.bavet.tri.UnindexedIfExistsTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetIfExistsConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
final class BavetIfExistsTriConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetIfExistsConstraintStream<Solution_> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC;
private final BavetForeBridgeUniConstraintStream<Solution_, D> parentBridgeD;
private final boolean shouldExist;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetIfExistsTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC,
BavetForeBridgeUniConstraintStream<Solution_, D> parentBridgeD,
boolean shouldExist,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, parentABC.getRetrievalSemantics());
this.parentABC = parentABC;
this.parentBridgeD = parentBridgeD;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABC.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABC.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeD.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABC.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<D> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsTriNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream)
: new IndexedIfExistsTriNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, filtering))
: (filtering == null ? new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()), downstream)
: new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, this, parentBridgeD);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetIfExistsTriConstraintStream<?, ?, ?, ?, ?> that = (BavetIfExistsTriConstraintStream<?, ?, ?, ?, ?>) object;
/*
* 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 ifExists node comes from.
*/
return shouldExist == that.shouldExist && Objects.equals(parentABC,
that.parentABC) && Objects.equals(
parentBridgeD.getParent(), that.parentBridgeD.getParent())
&& Objects.equals(joiner,
that.joiner)
&& Objects.equals(
filtering, that.filtering);
}
@Override
public int hashCode() {
return Objects.hash(parentABC, parentBridgeD.getParent(), shouldExist, joiner, filtering);
}
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return parentABC;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return parentBridgeD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetJoinTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.tri.IndexedJoinTriNode;
import ai.timefold.solver.core.impl.bavet.tri.UnindexedJoinTriNode;
import ai.timefold.solver.core.impl.bavet.tri.joiner.DefaultTriJoiner;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public final class BavetJoinTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetJoinConstraintStream<Solution_> {
private final BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent;
private final BavetForeBridgeUniConstraintStream<Solution_, C> rightParent;
private final DefaultTriJoiner<A, B, C> joiner;
private final TriPredicate<A, B, C> filtering;
public BavetJoinTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, C> rightParent,
DefaultTriJoiner<A, B, C> joiner, TriPredicate<A, B, C> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<C> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? new IndexedJoinTriNode<>(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, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1)
: new UnindexedJoinTriNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinTriConstraintStream<?, ?, ?, ?> other = (BavetJoinTriConstraintStream<?, ?, ?, ?>) 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 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 "TriJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetQuadGroupTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadGroupTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC, NewD>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetQuadGroupTriConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) 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 "QuadGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetQuadMapTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.tri.MapTriToQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadMapTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC, NewD>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private final TriFunction<A, B, C, NewC> mappingFunctionC;
private final TriFunction<A, B, C, NewD> mappingFunctionD;
private final boolean guaranteesDistinct;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB, TriFunction<A, B, C, NewC> mappingFunctionC,
TriFunction<A, B, C, NewD> mappingFunctionD, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.mappingFunctionD = mappingFunctionD;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node =
new MapTriToQuadNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetQuadMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?, ?> that =
(BavetQuadMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC,
that.mappingFunctionC)
&& Objects.equals(mappingFunctionD, that.mappingFunctionD);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "QuadMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetScoringTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import static ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream.impactWithConstraintMatchNoJustifications;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.common.inliner.ConstraintMatchSupplier;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class BavetScoringTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetScoringConstraintStream<Solution_> {
private final ToIntTriFunction<A, B, C> intMatchWeigher;
private final ToLongTriFunction<A, B, C> longMatchWeigher;
private final TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, ToIntTriFunction<A, B, C> intMatchWeigher) {
this(constraintFactory, parent, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, ToLongTriFunction<A, B, C> longMatchWeigher) {
this(constraintFactory, parent, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, ToIntTriFunction<A, B, C> intMatchWeigher,
ToLongTriFunction<A, B, C> longMatchWeigher, TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent);
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
var scoreImpacter = buildScoreImpacter(buildHelper.getScoreInliner().getConstraintMatchPolicy());
var weightedScoreImpacter = buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint);
var scorer = new TriScorer<>(weightedScoreImpacter, scoreImpacter,
buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
private QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter>
buildScoreImpacter(ConstraintMatchPolicy constraintMatchPolicy) {
return switch (constraintMatchPolicy) {
case DISABLED -> buildScoreImpacter();
case ENABLED -> buildScoreImpacterWithConstraintMatch();
case ENABLED_WITHOUT_JUSTIFICATIONS -> buildScoreImpacterWithConstraintMatchNoJustifications();
};
}
private QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> buildScoreImpacter() {
if (intMatchWeigher != null) {
return (impacter, a, b, c) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c);
return impacter.impactScore(matchWeight, null);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c);
return impacter.impactScore(matchWeight, null);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c);
return impacter.impactScore(matchWeight, null);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> buildScoreImpacterWithConstraintMatch() {
if (intMatchWeigher != null) {
return (impacter, a, b, c) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private static <A, B, C, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight, A a, B b, C c) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight, A a, B b, C c) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight, A a, B b, C c) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter>
buildScoreImpacterWithConstraintMatchNoJustifications() {
if (intMatchWeigher != null) {
return (impacter, a, b, c) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintRef() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetTriConcatTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.tri.ConcatTriTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
public final class BavetTriConcatTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final ConcatNodeConstructor<A, B, C> nodeConstructor;
public BavetTriConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatTriTriNode::new;
}
@Override
public boolean guaranteesDistinct() {
return false; // The two parents could have the same source; guarantee impossible.
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetTriConcatTriConstraintStream<?, ?, ?, ?> other = (BavetTriConcatTriConstraintStream<?, ?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "TriConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C> {
AbstractConcatNode<?, ?, ?> apply(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int leftCloneStoreIndex,
int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetTriGroupTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriGroupTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetTriGroupTriConstraintStream<?, ?, ?, ?, ?, ?, ?>) 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 "TriGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetTriMapTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.tri.MapTriToTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriMapTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private final TriFunction<A, B, C, NewC> mappingFunctionC;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB, TriFunction<A, B, C, NewC> mappingFunctionC) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapTriToTriNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetTriMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?> that = (BavetTriMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB) && Objects.equals(mappingFunctionC, that.mappingFunctionC);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "TriMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetUniConcatTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.tri.ConcatTriUniNode;
import ai.timefold.solver.core.impl.bavet.tri.ConcatUniTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public final class BavetUniConcatTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final Function<A, B> paddingFunctionB;
private final Function<A, C> paddingFunctionC;
private final ConcatNodeConstructor<A, B, C> nodeConstructor;
public BavetUniConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent,
Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
this.nodeConstructor = ConcatUniTriNode::new;
}
public BavetUniConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, A> rightParent,
Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
this.nodeConstructor = ConcatTriUniNode::new;
}
@Override
public boolean guaranteesDistinct() {
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
var leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
var rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
var outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(paddingFunctionB, paddingFunctionC, downstream, leftCloneStoreIndex,
rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
var other = (BavetUniConcatTriConstraintStream<?, ?, ?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "UniConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C> {
AbstractConcatNode<?, ?, ?> apply(Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetUniGroupTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniGroupTriConstraintStream<Solution_, A, B, C, NewA>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetUniGroupTriConstraintStream<?, ?, ?, ?, ?>) 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 "UniGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/BavetUniMapTriConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.tri.MapTriToUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniMapTriConstraintStream<Solution_, A, B, C, NewA>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapTriToUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetUniMapTriConstraintStream<?, ?, ?, ?, ?> that = (BavetUniMapTriConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/tri/TriScorer.java | package ai.timefold.solver.core.impl.score.stream.bavet.tri;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractScorer;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class TriScorer<A, B, C> extends AbstractScorer<TriTuple<A, B, C>> {
private final QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> scoreImpacter;
public TriScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter,
QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(weightedScoreImpacter, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(TriTuple<A, B, C> tuple) {
try {
return scoreImpacter.apply(weightedScoreImpacter, tuple.factA, tuple.factB, tuple.factC);
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetAbstractUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.fourKeysGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.oneKeyGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.threeKeysGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.twoKeysGroupBy;
import static ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor.zeroKeysGroupBy;
import static ai.timefold.solver.core.impl.score.stream.common.uni.InnerUniConstraintStream.createDefaultIndictedObjectsMapping;
import static ai.timefold.solver.core.impl.score.stream.common.uni.InnerUniConstraintStream.createDefaultJustificationMapping;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.impl.bavet.bi.joiner.BiJoinerComber;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.bavet.uni.Group0Mapping1CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group0Mapping2CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group0Mapping3CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group0Mapping4CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group1Mapping0CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group1Mapping1CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group1Mapping2CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group1Mapping3CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group2Mapping0CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group2Mapping1CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group2Mapping2CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group3Mapping0CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group3Mapping1CollectorUniNode;
import ai.timefold.solver.core.impl.bavet.uni.Group4Mapping0CollectorUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.bi.BavetJoinBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.bi.BavetUniConcatBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetAbstractQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.quad.BavetUniConcatQuadConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetAbstractTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.tri.BavetUniConcatTriConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
import ai.timefold.solver.core.impl.score.stream.common.uni.InnerUniConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.uni.UniConstraintBuilderImpl;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NonNull;
public abstract class BavetAbstractUniConstraintStream<Solution_, A> extends BavetAbstractConstraintStream<Solution_>
implements InnerUniConstraintStream<A> {
protected BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
protected BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public @NonNull UniConstraintStream<A> filter(@NonNull Predicate<A> predicate) {
return shareAndAddChild(new BavetFilterUniConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// Join
// ************************************************************************
@Override
@SafeVarargs
public final @NonNull <B> BiConstraintStream<A, B> join(@NonNull UniConstraintStream<B> otherStream,
@NonNull BiJoiner<A, B>... joiners) {
BiJoinerComber<A, B> joinerComber = BiJoinerComber.comb(joiners);
return join(otherStream, joinerComber);
}
@Override
public final <B> BiConstraintStream<A, B> join(UniConstraintStream<B> otherStream, BiJoinerComber<A, B> joinerComber) {
var other = (BavetAbstractUniConstraintStream<Solution_, B>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var joinStream = new BavetJoinBiConstraintStream<>(constraintFactory, leftBridge, rightBridge,
joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering());
return constraintFactory.share(joinStream, joinStream_ -> {
// Connect the bridges upstream, as it is an actual new join.
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final @NonNull <B> UniConstraintStream<A> ifExists(@NonNull UniConstraintStream<B> otherStream,
@NonNull BiJoiner<A, B>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final @NonNull <B> UniConstraintStream<A> ifNotExists(@NonNull UniConstraintStream<B> otherStream,
@NonNull BiJoiner<A, B>... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <B> UniConstraintStream<A> ifExistsOrNot(boolean shouldExist, UniConstraintStream<B> otherStream,
BiJoiner<A, B>[] joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, B>) otherStream;
var joinerComber = BiJoinerComber.comb(joiners);
var parentBridgeB = other.shareAndAddChild(new BavetForeBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsUniConstraintStream<>(constraintFactory, this, parentBridgeB,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public @NonNull <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
@NonNull UniConstraintCollector<A, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor =
zeroKeysGroupBy(collector, Group0Mapping1CollectorUniNode::new);
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
var stream = shareAndAddChild(new BavetUniGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
@NonNull UniConstraintCollector<A, ResultContainerA_, ResultA_> collectorA,
@NonNull UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, Group0Mapping2CollectorUniNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BavetBiGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(@NonNull UniConstraintCollector<A, ResultContainerA_, ResultA_> collectorA,
@NonNull UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
@NonNull UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, Group0Mapping3CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
var stream = shareAndAddChild(new BavetTriGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull UniConstraintCollector<A, ResultContainerA_, ResultA_> collectorA,
@NonNull UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
@NonNull UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC,
@NonNull UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, collectorD, Group0Mapping4CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
var stream = shareAndAddChild(new BavetQuadGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <GroupKey_> UniConstraintStream<GroupKey_> groupBy(@NonNull Function<A, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, Group1Mapping0CollectorUniNode::new);
return buildUniGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_> groupBy(@NonNull Function<A, GroupKey_> groupKeyMapping,
@NonNull UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
@NonNull UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, Group1Mapping2CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(@NonNull Function<A, GroupKey_> groupKeyMapping,
@NonNull UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
@NonNull UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC,
@NonNull UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, collectorD, Group1Mapping3CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> @NonNull BiConstraintStream<GroupKey_, Result_> groupBy(
@NonNull Function<A, GroupKey_> groupKeyMapping,
@NonNull UniConstraintCollector<A, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collector, Group1Mapping1CollectorUniNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
@NonNull Function<A, GroupKeyA_> groupKeyAMapping, @NonNull Function<A, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorUniNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_>
groupBy(
@NonNull Function<A, GroupKeyA_> groupKeyAMapping, @NonNull Function<A, GroupKeyB_> groupKeyBMapping,
@NonNull UniConstraintCollector<A, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collector, Group2Mapping1CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
@NonNull Function<A, GroupKeyA_> groupKeyAMapping, @NonNull Function<A, GroupKeyB_> groupKeyBMapping,
@NonNull UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC,
@NonNull UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collectorC, collectorD, Group2Mapping2CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
@NonNull Function<A, GroupKeyA_> groupKeyAMapping, @NonNull Function<A, GroupKeyB_> groupKeyBMapping,
@NonNull Function<A, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, Group3Mapping0CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(@NonNull Function<A, GroupKeyA_> groupKeyAMapping, @NonNull Function<A, GroupKeyB_> groupKeyBMapping,
@NonNull Function<A, GroupKeyC_> groupKeyCMapping,
@NonNull UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping,
groupKeyCMapping, collectorD, Group3Mapping1CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public @NonNull <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(@NonNull Function<A, GroupKeyA_> groupKeyAMapping, @NonNull Function<A, GroupKeyB_> groupKeyBMapping,
@NonNull Function<A, GroupKeyC_> groupKeyCMapping, @NonNull Function<A, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
fourKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping,
Group4Mapping0CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public @NonNull UniConstraintStream<A> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(ConstantLambdaUtils.identity());
}
}
@Override
public @NonNull UniConstraintStream<A> concat(@NonNull UniConstraintStream<A> otherStream) {
var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var concatStream = new BavetUniConcatUniConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <B> BiConstraintStream<A, B> concat(@NonNull BiConstraintStream<A, B> otherStream,
@NonNull Function<A, B> paddingFunction) {
var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
var concatStream = new BavetUniConcatBiConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunction);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <B, C> TriConstraintStream<A, B, C> concat(@NonNull TriConstraintStream<A, B, C> otherStream,
@NonNull Function<A, B> paddingFunctionB,
@NonNull Function<A, C> paddingFunctionC) {
var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, other);
var concatStream = new BavetUniConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunctionB,
paddingFunctionC);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <B, C, D> QuadConstraintStream<A, B, C, D> concat(@NonNull QuadConstraintStream<A, B, C, D> otherStream,
@NonNull Function<A, B> paddingFunctionB, @NonNull Function<A, C> paddingFunctionC,
@NonNull Function<A, D> paddingFunctionD) {
var other = (BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, other);
var concatStream =
new BavetUniConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge, paddingFunctionB,
paddingFunctionC, paddingFunctionD);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public @NonNull <ResultA_> UniConstraintStream<ResultA_> map(@NonNull Function<A, ResultA_> mapping) {
var stream = shareAndAddChild(new BavetUniMapUniConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_> BiConstraintStream<ResultA_, ResultB_> map(@NonNull Function<A, ResultA_> mappingA,
@NonNull Function<A, ResultB_> mappingB) {
var stream =
shareAndAddChild(new BavetBiMapUniConstraintStream<>(constraintFactory, this, mappingA, mappingB, false));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_, ResultC_> TriConstraintStream<ResultA_, ResultB_, ResultC_> map(
@NonNull Function<A, ResultA_> mappingA,
@NonNull Function<A, ResultB_> mappingB, @NonNull Function<A, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapUniConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC, false));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_> map(
@NonNull Function<A, ResultA_> mappingA, @NonNull Function<A, ResultB_> mappingB,
@NonNull Function<A, ResultC_> mappingC,
@NonNull Function<A, ResultD_> mappingD) {
var stream = shareAndAddChild(new BavetQuadMapUniConstraintStream<>(constraintFactory, this, mappingA, mappingB,
mappingC, mappingD, false));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultA_> UniConstraintStream<ResultA_> flattenLast(@NonNull Function<A, Iterable<ResultA_>> mapping) {
var stream = shareAndAddChild(new BavetFlattenLastUniConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Other operations
// ************************************************************************
@Override
public <ResultB_> @NonNull BiConstraintStream<A, ResultB_> expand(@NonNull Function<A, ResultB_> mapping) {
var stream =
shareAndAddChild(
new BavetBiMapUniConstraintStream<>(constraintFactory, this,
ConstantLambdaUtils.identity(), mapping, true));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public @NonNull <ResultB_, ResultC_> TriConstraintStream<A, ResultB_, ResultC_> expand(
@NonNull Function<A, ResultB_> mappingB,
@NonNull Function<A, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapUniConstraintStream<>(constraintFactory, this, ConstantLambdaUtils.identity(),
mappingB, mappingC,
true));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public @NonNull <ResultB_, ResultC_, ResultD_> QuadConstraintStream<A, ResultB_, ResultC_, ResultD_>
expand(@NonNull Function<A, ResultB_> mappingB, @NonNull Function<A, ResultC_> mappingC,
@NonNull Function<A, ResultD_> mappingD) {
var stream = shareAndAddChild(
new BavetQuadMapUniConstraintStream<>(constraintFactory, this, ConstantLambdaUtils.identity(),
mappingB,
mappingC, mappingD, true));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToIntFunction<A> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringUniConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> UniConstraintBuilderImpl<A, Score_> newTerminator(
BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new UniConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintDescription, constraintGroup, constraintWeight_, impactType_,
justificationMapping, indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName,
constraintDescription, constraintGroup, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToLongFunction<A> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringUniConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringUniConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final BiFunction<A, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return createDefaultJustificationMapping();
}
@Override
protected final Function<A, Collection<?>> getDefaultIndictedObjectsMapping() {
return createDefaultIndictedObjectsMapping();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetBiGroupUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiGroupUniConstraintStream<Solution_, A, NewA, NewB>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetBiGroupUniConstraintStream<?, ?, ?, ?>) 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/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetBiMapUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.uni.MapUniToBiNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
final class BavetBiMapUniConstraintStream<Solution_, A, NewA, NewB>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final boolean guaranteesDistinct;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunctionA,
Function<A, NewB> mappingFunctionB, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapUniToBiNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetBiMapUniConstraintStream<?, ?, ?, ?> that = (BavetBiMapUniConstraintStream<?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) &&
guaranteesDistinct == that.guaranteesDistinct && Objects.equals(mappingFunctionA,
that.mappingFunctionA)
&& Objects.equals(mappingFunctionB, that.mappingFunctionB);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetFilterUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.function.Predicate;
import ai.timefold.solver.core.api.score.Score;
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.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
final class BavetFilterUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Predicate<A> predicate;
public BavetFilterUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Predicate<A> predicate) {
super(constraintFactory, parent);
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
buildHelper.<UniTuple<A>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> TupleLifecycle.conditionally(tupleLifecycle, predicate));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterUniConstraintStream<?, ?> other) {
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetFlattenLastUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.uni.FlattenLastUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetFlattenLastUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, Iterable<NewA>> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> flattenLastStream;
public BavetFlattenLastUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
Function<A, Iterable<NewA>> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
var node = new FlattenLastUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetFlattenLastUniConstraintStream<?, ?, ?> that = (BavetFlattenLastUniConstraintStream<?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "FlattenLast()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetForEachUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.ForEachFilteredUniNode;
import ai.timefold.solver.core.impl.bavet.uni.ForEachUnfilteredUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class BavetForEachUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements TupleSource {
private final Class<A> forEachClass;
@Nullable
private final Function<ConstraintNodeBuildHelper<Solution_, ?>, Predicate<A>> filterFunction;
public BavetForEachUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory, Class<A> forEachClass,
@Nullable Function<ConstraintNodeBuildHelper<Solution_, ?>, Predicate<A>> filterFunction,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
this.forEachClass = forEachClass;
if (forEachClass == null) {
throw new IllegalArgumentException("The forEachClass (null) cannot be null.");
}
this.filterFunction = filterFunction;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<UniTuple<A>> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var filter = filterFunction != null ? filterFunction.apply(buildHelper) : null;
var node = filter == null ? new ForEachUnfilteredUniNode<>(forEachClass, tupleLifecycle, outputStoreSize)
: new ForEachFilteredUniNode<>(forEachClass, filter, tupleLifecycle,
outputStoreSize);
buildHelper.addNode(node, this, null);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (other == null || getClass() != other.getClass()) {
return false;
}
BavetForEachUniConstraintStream<?, ?> that = (BavetForEachUniConstraintStream<?, ?>) other;
return Objects.equals(forEachClass, that.forEachClass) && Objects.equals(filterFunction, that.filterFunction);
}
@Override
public int hashCode() {
return Objects.hash(forEachClass, filterFunction);
}
@Override
public String toString() {
if (filterFunction != null) {
return "ForEach(" + forEachClass.getSimpleName() + ") with filter and " + childStreamList.size() + " children";
}
return "ForEach(" + forEachClass.getSimpleName() + ") with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetIfExistsUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.bi.joiner.DefaultBiJoiner;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
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.IndexedIfExistsUniNode;
import ai.timefold.solver.core.impl.bavet.uni.UnindexedIfExistsUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetIfExistsConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
final class BavetIfExistsUniConstraintStream<Solution_, A, B>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetIfExistsConstraintStream<Solution_> {
private final BavetAbstractUniConstraintStream<Solution_, A> parentA;
private final BavetForeBridgeUniConstraintStream<Solution_, B> parentBridgeB;
private final boolean shouldExist;
private final DefaultBiJoiner<A, B> joiner;
private final BiPredicate<A, B> filtering;
public BavetIfExistsUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parentA,
BavetForeBridgeUniConstraintStream<Solution_, B> parentBridgeB,
boolean shouldExist,
DefaultBiJoiner<A, B> joiner, BiPredicate<A, B> filtering) {
super(constraintFactory, parentA.getRetrievalSemantics());
this.parentA = parentA;
this.parentBridgeB = parentBridgeB;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentA.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentA.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeB.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentA.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<UniTuple<A>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<B> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsUniNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
downstream)
: new IndexedIfExistsUniNode<>(shouldExist, indexerFactory,
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
downstream, filtering))
: (filtering == null ? new UnindexedIfExistsUniNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()), downstream)
: new UnindexedIfExistsUniNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, this, parentBridgeB);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetIfExistsUniConstraintStream<?, ?, ?> that = (BavetIfExistsUniConstraintStream<?, ?, ?>) object;
/*
* 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 ifExists node comes from.
*/
return shouldExist == that.shouldExist && Objects.equals(parentA,
that.parentA) && Objects.equals(
parentBridgeB.getParent(), that.parentBridgeB.getParent())
&& Objects.equals(joiner,
that.joiner)
&& Objects.equals(
filtering, that.filtering);
}
@Override
public int hashCode() {
return Objects.hash(parentA, parentBridgeB.getParent(), shouldExist, joiner, filtering);
}
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return parentA;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return parentBridgeB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetQuadGroupUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadGroupUniConstraintStream<Solution_, A, NewA, NewB, NewC, NewD>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetQuadGroupUniConstraintStream<?, ?, ?, ?, ?, ?>) 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 "QuadGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetQuadMapUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.uni.MapUniToQuadNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
final class BavetQuadMapUniConstraintStream<Solution_, A, NewA, NewB, NewC, NewD>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
private final Function<A, NewD> mappingFunctionD;
private final boolean guaranteesDistinct;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunctionA,
Function<A, NewB> mappingFunctionB, Function<A, NewC> mappingFunctionC, Function<A, NewD> mappingFunctionD,
boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.mappingFunctionD = mappingFunctionD;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node =
new MapUniToQuadNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetQuadMapUniConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetQuadMapUniConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC,
that.mappingFunctionC)
&& Objects.equals(mappingFunctionD, that.mappingFunctionD);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "QuadMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetScoringUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import static ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream.impactWithConstraintMatchNoJustifications;
import java.math.BigDecimal;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.common.inliner.ConstraintMatchSupplier;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class BavetScoringUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetScoringConstraintStream<Solution_> {
private final ToIntFunction<A> intMatchWeigher;
private final ToLongFunction<A> longMatchWeigher;
private final Function<A, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, ToIntFunction<A> intMatchWeigher) {
this(constraintFactory, parent, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, ToLongFunction<A> longMatchWeigher) {
this(constraintFactory, parent, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, ToIntFunction<A> intMatchWeigher,
ToLongFunction<A> longMatchWeigher, Function<A, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent);
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
var scoreImpacter = buildScoreImpacter(buildHelper.getScoreInliner().getConstraintMatchPolicy());
var weightedScoreImpacter = buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint);
var scorer = new UniScorer<>(weightedScoreImpacter, scoreImpacter,
buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
private BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter>
buildScoreImpacter(ConstraintMatchPolicy constraintMatchPolicy) {
return switch (constraintMatchPolicy) {
case DISABLED -> buildScoreImpacter();
case ENABLED -> buildScoreImpacterWithConstraintMatch();
case ENABLED_WITHOUT_JUSTIFICATIONS -> buildScoreImpacterWithConstraintMatchNoJustifications();
};
}
private BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> buildScoreImpacter() {
if (intMatchWeigher != null) {
return (impacter, a) -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
return impacter.impactScore(matchWeight, null);
};
} else if (longMatchWeigher != null) {
return (impacter, a) -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
return impacter.impactScore(matchWeight, null);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
return impacter.impactScore(matchWeight, null);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> buildScoreImpacterWithConstraintMatch() {
if (intMatchWeigher != null) {
return (impacter, a) -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
return impactWithConstraintMatch(impacter, matchWeight, a);
};
} else if (longMatchWeigher != null) {
return (impacter, a) -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
return impactWithConstraintMatch(impacter, matchWeight, a);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
return impactWithConstraintMatch(impacter, matchWeight, a);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private static <A, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight, A a) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight, A a) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight, A a) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter>
buildScoreImpacterWithConstraintMatchNoJustifications() {
if (intMatchWeigher != null) {
return (impacter, a) -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (longMatchWeigher != null) {
return (impacter, a) -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
return impactWithConstraintMatchNoJustifications(impacter, matchWeight);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintRef() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetTriGroupUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriGroupUniConstraintStream<Solution_, A, NewA, NewB, NewC>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetTriGroupUniConstraintStream<?, ?, ?, ?, ?>) 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 "TriGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetTriMapUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.uni.MapUniToTriNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
final class BavetTriMapUniConstraintStream<Solution_, A, NewA, NewB, NewC>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
private final boolean guaranteesDistinct;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunctionA,
Function<A, NewB> mappingFunctionB, Function<A, NewC> mappingFunctionC, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapUniToTriNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetTriMapUniConstraintStream<?, ?, ?, ?, ?> that = (BavetTriMapUniConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC, that.mappingFunctionC);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "TriMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetUniConcatUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
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.ConcatUniUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
public final class BavetUniConcatUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetConcatConstraintStream<Solution_> {
private final BavetForeBridgeUniConstraintStream<Solution_, A> leftParent;
private final BavetForeBridgeUniConstraintStream<Solution_, A> rightParent;
public BavetUniConcatUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, A> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
TupleLifecycle<UniTuple<A>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = new ConcatUniUniNode<>(downstream,
leftCloneStoreIndex,
rightCloneStoreIndex,
outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetUniConcatUniConstraintStream<?, ?> other = (BavetUniConcatUniConstraintStream<?, ?>) 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 concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "UniConcat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetUniGroupUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniGroupUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
var aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetUniGroupUniConstraintStream<?, ?, ?>) 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 "UniGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/BavetUniMapUniConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.bavet.uni.MapUniToUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
final class BavetUniMapUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapUniToUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetUniMapUniConstraintStream<?, ?, ?> that = (BavetUniMapUniConstraintStream<?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/bavet/uni/UniScorer.java | package ai.timefold.solver.core.impl.score.stream.bavet.uni;
import java.util.function.BiFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractScorer;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
final class UniScorer<A> extends AbstractScorer<UniTuple<A>> {
private final BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> scoreImpacter;
public UniScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter,
BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(weightedScoreImpacter, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(UniTuple<A> tuple) {
try {
return scoreImpacter.apply(weightedScoreImpacter, tuple.factA);
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/ConnectedRangesCalculator.java | package ai.timefold.solver.core.impl.score.stream.collector;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.common.ConnectedRangeChain;
import ai.timefold.solver.core.impl.score.stream.collector.connected_ranges.ConnectedRangeTracker;
import ai.timefold.solver.core.impl.score.stream.collector.connected_ranges.Range;
public final class ConnectedRangesCalculator<Interval_, Point_ extends Comparable<Point_>, Difference_ extends Comparable<Difference_>>
implements
ObjectCalculator<Interval_, ConnectedRangeChain<Interval_, Point_, Difference_>, Range<Interval_, Point_>> {
private final ConnectedRangeTracker<Interval_, Point_, Difference_> context;
public ConnectedRangesCalculator(Function<? super Interval_, ? extends Point_> startMap,
Function<? super Interval_, ? extends Point_> endMap,
BiFunction<? super Point_, ? super Point_, ? extends Difference_> differenceFunction) {
this.context = new ConnectedRangeTracker<>(
startMap,
endMap,
differenceFunction);
}
@Override
public Range<Interval_, Point_> insert(Interval_ result) {
final var saved = context.getRange(result);
context.add(saved);
return saved;
}
@Override
public void retract(Range<Interval_, Point_> range) {
context.remove(range);
}
@Override
public ConnectedRangeChain<Interval_, Point_, Difference_> result() {
return context.getConnectedRangeChain();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/CustomCollectionUndoableActionable.java | package ai.timefold.solver.core.impl.score.stream.collector;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.IntFunction;
public final class CustomCollectionUndoableActionable<Mapped_, Result_ extends Collection<Mapped_>>
implements UndoableActionable<Mapped_, Result_> {
private final IntFunction<Result_> collectionFunction;
private final List<Mapped_> resultList = new ArrayList<>();
public CustomCollectionUndoableActionable(IntFunction<Result_> collectionFunction) {
this.collectionFunction = collectionFunction;
}
@Override
public Runnable insert(Mapped_ result) {
resultList.add(result);
return () -> resultList.remove(result);
}
@Override
public Result_ result() {
Result_ out = collectionFunction.apply(resultList.size());
if (resultList.isEmpty()) {
// Avoid exception if out is an immutable collection
return out;
}
out.addAll(resultList);
return out;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/IntAverageCalculator.java | package ai.timefold.solver.core.impl.score.stream.collector;
public final class IntAverageCalculator implements IntCalculator<Double> {
int count = 0;
int sum = 0;
@Override
public void insert(int input) {
count++;
sum += input;
}
@Override
public void retract(int input) {
count--;
sum -= input;
}
@Override
public Double result() {
if (count == 0) {
return null;
}
return sum / (double) count;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/IntCalculator.java | package ai.timefold.solver.core.impl.score.stream.collector;
public sealed interface IntCalculator<Output_> permits IntAverageCalculator, IntSumCalculator {
void insert(int input);
void retract(int input);
Output_ result();
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.