index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/ConstraintMatchSupplier.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatch;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
/**
* Allows creating {@link ConstraintMatch} instances lazily if and only if they are required by the end user.
* <p>
* Lazy behavior is important for constraint matching performance.
* In order to create {@link ConstraintMatch}, an entire {@link ConstraintJustification} object needs to be created,
* along with the collection of indicted objects.
* Creating these structures every time a constraint is matched would be wasteful,
* as the same constraint match can be undone almost immediately, resulting in a lot of pointless garbage.
* Therefore, {@link ConstraintMatch} (along with all of its supporting data structures)
* is only created when actually needed, and that is during score explanation.
* Until that point, this thin wrapper serves as a placeholder which understands what to create when needed.
*/
@FunctionalInterface
public interface ConstraintMatchSupplier<Score_ extends Score<Score_>>
extends BiFunction<Constraint, Score_, ConstraintMatch<Score_>> {
static <Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> empty() {
return (constraint, impact) -> new ConstraintMatch<>(constraint.getConstraintRef(),
DefaultConstraintJustification.of(impact),
Collections.emptyList(), impact);
}
static <A, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
BiFunction<A, Score<?>, ConstraintJustification> justificationMapping,
Function<A, Collection<Object>> indictedObjectsMapping,
A a) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
private static RuntimeException createJustificationException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintRef()
+ ") threw an exception creating constraint justification from a tuple (" + factsToString(facts) + ").", cause);
}
private static String factsToString(Object... facts) {
return Arrays.stream(facts)
.map(Objects::toString)
.collect(Collectors.joining(", ", "{", "}"));
}
private static RuntimeException createIndictmentException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintRef()
+ ") threw an exception collecting indicted objects from a tuple (" + factsToString(facts) + ").", cause);
}
static <A, B, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
TriFunction<A, B, Score_, ConstraintJustification> justificationMapping,
BiFunction<A, B, Collection<Object>> indictedObjectsMapping,
A a, B b) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, b, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a, b);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
static <A, B, C, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
QuadFunction<A, B, C, Score_, ConstraintJustification> justificationMapping,
TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping,
A a, B b, C c) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, b, c, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a, b, c);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
static <A, B, C, D, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
PentaFunction<A, B, C, D, Score_, ConstraintJustification> justificationMapping,
QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping,
A a, B b, C c, D d) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, b, c, d, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c, d);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a, b, c, d);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c, d);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftBigDecimalScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
final class HardMediumSoftBigDecimalScoreContext
extends ScoreContext<HardMediumSoftBigDecimalScore, HardMediumSoftBigDecimalScoreInliner> {
public HardMediumSoftBigDecimalScoreContext(HardMediumSoftBigDecimalScoreInliner parent,
AbstractConstraint<?, ?, ?> constraint, HardMediumSoftBigDecimalScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
parent.softScore = parent.softScore.add(softImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.softScore = parent.softScore.subtract(softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofSoft(softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
parent.mediumScore = parent.mediumScore.add(mediumImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.mediumScore = parent.mediumScore.subtract(mediumImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofMedium(mediumImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
parent.hardScore = parent.hardScore.add(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore = parent.hardScore.subtract(hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofHard(hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
parent.hardScore = parent.hardScore.add(hardImpact);
parent.mediumScore = parent.mediumScore.add(mediumImpact);
parent.softScore = parent.softScore.add(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore = parent.hardScore.subtract(hardImpact);
parent.mediumScore = parent.mediumScore.subtract(mediumImpact);
parent.softScore = parent.softScore.subtract(softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
HardMediumSoftBigDecimalScore.of(hardImpact, mediumImpact, softImpact), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftBigDecimalScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftBigDecimalScoreInliner extends AbstractScoreInliner<HardMediumSoftBigDecimalScore> {
BigDecimal hardScore = BigDecimal.ZERO;
BigDecimal mediumScore = BigDecimal.ZERO;
BigDecimal softScore = BigDecimal.ZERO;
HardMediumSoftBigDecimalScoreInliner(Map<Constraint, HardMediumSoftBigDecimalScore> constraintWeightMap,
boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftBigDecimalScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
HardMediumSoftBigDecimalScore constraintWeight = constraintWeightMap.get(constraint);
BigDecimal hardConstraintWeight = constraintWeight.hardScore();
BigDecimal mediumConstraintWeight = constraintWeight.mediumScore();
BigDecimal softConstraintWeight = constraintWeight.softScore();
HardMediumSoftBigDecimalScoreContext context =
new HardMediumSoftBigDecimalScoreContext(this, constraint, constraintWeight);
if (mediumConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeHardScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeMediumScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && mediumConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeScoreBy);
}
}
@Override
public HardMediumSoftBigDecimalScore extractScore(int initScore) {
return HardMediumSoftBigDecimalScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
final class HardMediumSoftLongScoreContext extends ScoreContext<HardMediumSoftLongScore, HardMediumSoftLongScoreInliner> {
public HardMediumSoftLongScoreContext(HardMediumSoftLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
HardMediumSoftLongScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long softImpact = constraintWeight.softScore() * matchWeight;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScore -= softImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofSoft(softImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
parent.mediumScore += mediumImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.mediumScore -= mediumImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofMedium(mediumImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
parent.hardScore += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore -= hardImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofHard(hardImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
long softImpact = constraintWeight.softScore() * matchWeight;
parent.hardScore += hardImpact;
parent.mediumScore += mediumImpact;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore -= hardImpact;
parent.mediumScore -= mediumImpact;
parent.softScore -= softImpact;
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.of(hardImpact, mediumImpact, softImpact),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftLongScoreInliner extends AbstractScoreInliner<HardMediumSoftLongScore> {
long hardScore;
long mediumScore;
long softScore;
HardMediumSoftLongScoreInliner(Map<Constraint, HardMediumSoftLongScore> constraintWeightMap,
boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftLongScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
HardMediumSoftLongScore constraintWeight = constraintWeightMap.get(constraint);
long hardConstraintWeight = constraintWeight.hardScore();
long mediumConstraintWeight = constraintWeight.mediumScore();
long softConstraintWeight = constraintWeight.softScore();
HardMediumSoftLongScoreContext context = new HardMediumSoftLongScoreContext(this, constraint, constraintWeight);
if (mediumConstraintWeight == 0L && softConstraintWeight == 0L) {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) -> ctx
.changeHardScoreBy(matchWeight, constraintMatchSupplier));
} else if (hardConstraintWeight == 0L && softConstraintWeight == 0L) {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) -> ctx
.changeMediumScoreBy(matchWeight, constraintMatchSupplier));
} else if (hardConstraintWeight == 0L && mediumConstraintWeight == 0L) {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) -> ctx
.changeSoftScoreBy(matchWeight, constraintMatchSupplier));
} else {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) -> ctx
.changeScoreBy(matchWeight, constraintMatchSupplier));
}
}
@Override
public HardMediumSoftLongScore extractScore(int initScore) {
return HardMediumSoftLongScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
final class HardMediumSoftScoreContext extends ScoreContext<HardMediumSoftScore, HardMediumSoftScoreInliner> {
public HardMediumSoftScoreContext(HardMediumSoftScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
HardMediumSoftScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight,
ConstraintMatchSupplier<HardMediumSoftScore> constraintMatchSupplier) {
int softImpact = constraintWeight.softScore() * matchWeight;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScore -= softImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.ofSoft(softImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(int matchWeight,
ConstraintMatchSupplier<HardMediumSoftScore> constraintMatchSupplier) {
int mediumImpact = constraintWeight.mediumScore() * matchWeight;
parent.mediumScore += mediumImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.mediumScore -= mediumImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.ofMedium(mediumImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight,
ConstraintMatchSupplier<HardMediumSoftScore> constraintMatchSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
parent.hardScore += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore -= hardImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.ofHard(hardImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight,
ConstraintMatchSupplier<HardMediumSoftScore> constraintMatchSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
int mediumImpact = constraintWeight.mediumScore() * matchWeight;
int softImpact = constraintWeight.softScore() * matchWeight;
parent.hardScore += hardImpact;
parent.mediumScore += mediumImpact;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore -= hardImpact;
parent.mediumScore -= mediumImpact;
parent.softScore -= softImpact;
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.of(hardImpact, mediumImpact, softImpact),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftScoreInliner extends AbstractScoreInliner<HardMediumSoftScore> {
int hardScore;
int mediumScore;
int softScore;
HardMediumSoftScoreInliner(Map<Constraint, HardMediumSoftScore> constraintWeightMap, boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
HardMediumSoftScore constraintWeight = constraintWeightMap.get(constraint);
int hardConstraintWeight = constraintWeight.hardScore();
int mediumConstraintWeight = constraintWeight.mediumScore();
int softConstraintWeight = constraintWeight.softScore();
HardMediumSoftScoreContext context = new HardMediumSoftScoreContext(this, constraint, constraintWeight);
if (mediumConstraintWeight == 0 && softConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeHardScoreBy);
} else if (hardConstraintWeight == 0 && softConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeMediumScoreBy);
} else if (hardConstraintWeight == 0 && mediumConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeScoreBy);
}
}
@Override
public HardMediumSoftScore extractScore(int initScore) {
return HardMediumSoftScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardSoftBigDecimalScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
final class HardSoftBigDecimalScoreContext extends ScoreContext<HardSoftBigDecimalScore, HardSoftBigDecimalScoreInliner> {
public HardSoftBigDecimalScoreContext(HardSoftBigDecimalScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
HardSoftBigDecimalScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
parent.softScore = parent.softScore.add(softImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.softScore = parent.softScore.subtract(softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.ofSoft(softImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
parent.hardScore = parent.hardScore.add(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore = parent.hardScore.subtract(hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.ofHard(hardImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
parent.hardScore = parent.hardScore.add(hardImpact);
parent.softScore = parent.softScore.add(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore = parent.hardScore.subtract(hardImpact);
parent.softScore = parent.softScore.subtract(softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.of(hardImpact, softImpact),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardSoftBigDecimalScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftBigDecimalScoreInliner extends AbstractScoreInliner<HardSoftBigDecimalScore> {
BigDecimal hardScore = BigDecimal.ZERO;
BigDecimal softScore = BigDecimal.ZERO;
HardSoftBigDecimalScoreInliner(Map<Constraint, HardSoftBigDecimalScore> constraintWeightMap,
boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftBigDecimalScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
HardSoftBigDecimalScore constraintWeight = constraintWeightMap.get(constraint);
HardSoftBigDecimalScoreContext context = new HardSoftBigDecimalScoreContext(this, constraint, constraintWeight);
if (constraintWeight.softScore().equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeHardScoreBy);
} else if (constraintWeight.hardScore().equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeScoreBy);
}
}
@Override
public HardSoftBigDecimalScore extractScore(int initScore) {
return HardSoftBigDecimalScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardSoftLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
final class HardSoftLongScoreContext extends ScoreContext<HardSoftLongScore, HardSoftLongScoreInliner> {
public HardSoftLongScoreContext(HardSoftLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
HardSoftLongScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight,
ConstraintMatchSupplier<HardSoftLongScore> constraintMatchSupplier) {
long softImpact = constraintWeight.softScore() * matchWeight;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScore -= softImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.ofSoft(softImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight,
ConstraintMatchSupplier<HardSoftLongScore> constraintMatchSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
parent.hardScore += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore -= hardImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.ofHard(hardImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight,
ConstraintMatchSupplier<HardSoftLongScore> constraintMatchSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
long softImpact = constraintWeight.softScore() * matchWeight;
parent.hardScore += hardImpact;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore -= hardImpact;
parent.softScore -= softImpact;
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.of(hardImpact, softImpact),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardSoftLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftLongScoreInliner extends AbstractScoreInliner<HardSoftLongScore> {
long hardScore;
long softScore;
HardSoftLongScoreInliner(Map<Constraint, HardSoftLongScore> constraintWeightMap, boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftLongScore, ?> buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
HardSoftLongScore constraintWeight = constraintWeightMap.get(constraint);
HardSoftLongScoreContext context = new HardSoftLongScoreContext(this, constraint, constraintWeight);
if (constraintWeight.softScore() == 0L) {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<HardSoftLongScore> constraintMatchSupplier) -> ctx
.changeHardScoreBy(matchWeight, constraintMatchSupplier));
} else if (constraintWeight.hardScore() == 0L) {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<HardSoftLongScore> constraintMatchSupplier) -> ctx
.changeSoftScoreBy(matchWeight, constraintMatchSupplier));
} else {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<HardSoftLongScore> constraintMatchSupplier) -> ctx
.changeScoreBy(matchWeight, constraintMatchSupplier));
}
}
@Override
public HardSoftLongScore extractScore(int initScore) {
return HardSoftLongScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardSoftScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
final class HardSoftScoreContext extends ScoreContext<HardSoftScore, HardSoftScoreInliner> {
public HardSoftScoreContext(HardSoftScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
HardSoftScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight,
ConstraintMatchSupplier<HardSoftScore> constraintMatchSupplier) {
int softImpact = constraintWeight.softScore() * matchWeight;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScore -= softImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.ofSoft(softImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight,
ConstraintMatchSupplier<HardSoftScore> constraintMatchSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
parent.hardScore += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore -= hardImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.ofHard(hardImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, ConstraintMatchSupplier<HardSoftScore> constraintMatchSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
int softImpact = constraintWeight.softScore() * matchWeight;
parent.hardScore += hardImpact;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore -= hardImpact;
parent.softScore -= softImpact;
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.of(hardImpact, softImpact), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/HardSoftScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftScoreInliner extends AbstractScoreInliner<HardSoftScore> {
int hardScore;
int softScore;
HardSoftScoreInliner(Map<Constraint, HardSoftScore> constraintWeightMap, boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftScore, ?> buildWeightedScoreImpacter(
AbstractConstraint<?, ?, ?> constraint) {
HardSoftScore constraintWeight = constraintWeightMap.get(constraint);
HardSoftScoreContext context = new HardSoftScoreContext(this, constraint, constraintWeight);
if (constraintWeight.softScore() == 0) {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeHardScoreBy);
} else if (constraintWeight.hardScore() == 0) {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeScoreBy);
}
}
@Override
public HardSoftScore extractScore(int initScore) {
return HardSoftScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/IntWeightedScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
final class IntWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>>
implements WeightedScoreImpacter<Score_, Context_> {
private final IntImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public IntWeightedScoreImpacter(IntImpactFunction<Score_, Context_> impactFunction, Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, matchWeight, constraintMatchSupplier);
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
throw new UnsupportedOperationException("Impossible state: passing long into an int impacter.");
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
throw new UnsupportedOperationException("Impossible state: passing BigDecimal into an int impacter.");
}
@Override
public Context_ getContext() {
return context;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/LongWeightedScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
final class LongWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>>
implements WeightedScoreImpacter<Score_, Context_> {
private final LongImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public LongWeightedScoreImpacter(LongImpactFunction<Score_, Context_> impactFunction, Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, matchWeight, constraintMatchSupplier); // int can be cast to long
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, matchWeight, constraintMatchSupplier);
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
throw new UnsupportedOperationException("Impossible state: passing BigDecimal into a long impacter.");
}
@Override
public Context_ getContext() {
return context;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/ScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.Score;
public abstract class ScoreContext<Score_ extends Score<Score_>, ScoreInliner_ extends AbstractScoreInliner<Score_>> {
protected final ScoreInliner_ parent;
protected final AbstractConstraint<?, ?, ?> constraint;
protected final Score_ constraintWeight;
protected final boolean constraintMatchEnabled;
protected ScoreContext(ScoreInliner_ parent, AbstractConstraint<?, ?, ?> constraint, Score_ constraintWeight) {
this.parent = parent;
this.constraint = constraint;
this.constraintWeight = constraintWeight;
this.constraintMatchEnabled = parent.constraintMatchEnabled;
}
public AbstractConstraint<?, ?, ?> getConstraint() {
return constraint;
}
public Score_ getConstraintWeight() {
return constraintWeight;
}
public boolean isConstraintMatchEnabled() {
return constraintMatchEnabled;
}
protected UndoScoreImpacter impactWithConstraintMatch(UndoScoreImpacter undoScoreImpact, Score_ score,
ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
return parent.addConstraintMatch(constraint, score, constraintMatchSupplier, undoScoreImpact);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/SimpleBigDecimalScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
final class SimpleBigDecimalScoreContext extends ScoreContext<SimpleBigDecimalScore, SimpleBigDecimalScoreInliner> {
public SimpleBigDecimalScoreContext(SimpleBigDecimalScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
SimpleBigDecimalScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<SimpleBigDecimalScore> constraintMatchSupplier) {
BigDecimal impact = constraintWeight.score().multiply(matchWeight);
parent.score = parent.score.add(impact);
UndoScoreImpacter undoScoreImpact = () -> parent.score = parent.score.subtract(impact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleBigDecimalScore.of(impact), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/SimpleBigDecimalScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleBigDecimalScoreInliner extends AbstractScoreInliner<SimpleBigDecimalScore> {
BigDecimal score = BigDecimal.ZERO;
SimpleBigDecimalScoreInliner(Map<Constraint, SimpleBigDecimalScore> constraintWeightMap, boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleBigDecimalScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
SimpleBigDecimalScore constraintWeight = constraintWeightMap.get(constraint);
SimpleBigDecimalScoreContext context = new SimpleBigDecimalScoreContext(this, constraint, constraintWeight);
return WeightedScoreImpacter.of(context, SimpleBigDecimalScoreContext::changeScoreBy);
}
@Override
public SimpleBigDecimalScore extractScore(int initScore) {
return SimpleBigDecimalScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/SimpleLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
final class SimpleLongScoreContext extends ScoreContext<SimpleLongScore, SimpleLongScoreInliner> {
public SimpleLongScoreContext(SimpleLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
SimpleLongScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeScoreBy(long matchWeight, ConstraintMatchSupplier<SimpleLongScore> constraintMatchSupplier) {
long impact = constraintWeight.score() * matchWeight;
parent.score += impact;
UndoScoreImpacter undoScoreImpact = () -> parent.score -= impact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleLongScore.of(impact), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/SimpleLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleLongScoreInliner extends AbstractScoreInliner<SimpleLongScore> {
long score;
SimpleLongScoreInliner(Map<Constraint, SimpleLongScore> constraintWeightMap, boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleLongScore, ?> buildWeightedScoreImpacter(
AbstractConstraint<?, ?, ?> constraint) {
SimpleLongScore constraintWeight = constraintWeightMap.get(constraint);
SimpleLongScoreContext context = new SimpleLongScoreContext(this, constraint, constraintWeight);
return WeightedScoreImpacter.of(context,
(SimpleLongScoreContext ctx, long matchWeight,
ConstraintMatchSupplier<SimpleLongScore> constraintMatchSupplier) -> ctx
.changeScoreBy(matchWeight, constraintMatchSupplier));
}
@Override
public SimpleLongScore extractScore(int initScore) {
return SimpleLongScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/SimpleScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
final class SimpleScoreContext extends ScoreContext<SimpleScore, SimpleScoreInliner> {
public SimpleScoreContext(SimpleScoreInliner parent, AbstractConstraint<?, ?, ?> constraint, SimpleScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, ConstraintMatchSupplier<SimpleScore> constraintMatchSupplier) {
int impact = constraintWeight.score() * matchWeight;
parent.score += impact;
UndoScoreImpacter undoScoreImpact = () -> parent.score -= impact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleScore.of(impact), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/SimpleScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleScoreInliner extends AbstractScoreInliner<SimpleScore> {
int score;
SimpleScoreInliner(Map<Constraint, SimpleScore> constraintWeightMap, boolean constraintMatchEnabled) {
super(constraintWeightMap, constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleScore, ?> buildWeightedScoreImpacter(
AbstractConstraint<?, ?, ?> constraint) {
SimpleScore constraintWeight = constraintWeightMap.get(constraint);
SimpleScoreContext context = new SimpleScoreContext(this, constraint, constraintWeight);
return WeightedScoreImpacter.of(context, SimpleScoreContext::changeScoreBy);
}
@Override
public SimpleScore extractScore(int initScore) {
return SimpleScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/UndoScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
@FunctionalInterface
public interface UndoScoreImpacter extends Runnable {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/WeightedScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.score.Score;
/**
* There are several valid ways how an impacter could be called from a constraint stream:
*
* <ul>
* <li>{@code .penalize(..., (int) 1)}</li>
* <li>{@code .penalizeLong(..., (int) 1)}</li>
* <li>{@code .penalizeLong(..., (long) 1)}</li>
* <li>{@code .penalizeBigDecimal(..., (int) 1)}</li>
* <li>{@code .penalizeBigDecimal(..., (long) 1)}</li>
* <li>{@code .penalizeBigDecimal(..., BigDecimal.ONE)}</li>
* <li>Plus reward variants of the above.</li>
* </ul>
*
* An implementation of this interface can throw an {@link UnsupportedOperationException}
* for the method types it doesn't support. The CS API guarantees no types are mixed. For example,
* a {@link BigDecimal} parameter method won't be called on an instance built with an {@link IntImpactFunction}.
*/
public interface WeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>> {
static <Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>> WeightedScoreImpacter<Score_, Context_>
of(Context_ context, IntImpactFunction<Score_, Context_> impactFunction) {
return new IntWeightedScoreImpacter<>(impactFunction, context);
}
static <Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>> WeightedScoreImpacter<Score_, Context_>
of(Context_ context, LongImpactFunction<Score_, Context_> impactFunction) {
return new LongWeightedScoreImpacter<>(impactFunction, context);
}
static <Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>> WeightedScoreImpacter<Score_, Context_>
of(Context_ context, BigDecimalImpactFunction<Score_, Context_> impactFunction) {
return new BigDecimalWeightedScoreImpacter<>(impactFunction, context);
}
/**
* @param matchWeight never null
* @param constraintMatchSupplier ignored unless constraint match enableds
* @return never null
*/
UndoScoreImpacter impactScore(int matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier);
/**
* @param matchWeight never null
* @param constraintMatchSupplier ignored unless constraint match enabled
* @return never null
*/
UndoScoreImpacter impactScore(long matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier);
/**
* @param matchWeight never null
* @param constraintMatchSupplier ignored unless constraint match enabled
* @return never null
*/
UndoScoreImpacter impactScore(BigDecimal matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier);
Context_ getContext();
@FunctionalInterface
interface IntImpactFunction<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>> {
UndoScoreImpacter impact(Context_ context, int matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier);
}
@FunctionalInterface
interface LongImpactFunction<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>> {
UndoScoreImpacter impact(Context_ context, long matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier);
}
@FunctionalInterface
interface BigDecimalImpactFunction<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>> {
UndoScoreImpacter impact(Context_ context, BigDecimal matchWeight,
ConstraintMatchSupplier<Score_> constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/penta/DefaultPentaJoiner.java | package ai.timefold.solver.constraint.streams.common.penta;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultPentaJoiner<A, B, C, D, E> extends AbstractJoiner<E> implements PentaJoiner<A, B, C, D, E> {
private static final DefaultPentaJoiner NONE =
new DefaultPentaJoiner(new QuadFunction[0], new JoinerType[0], new Function[0]);
private final QuadFunction<A, B, C, D, ?>[] leftMappings;
public <Property_> DefaultPentaJoiner(QuadFunction<A, B, C, D, Property_> leftMapping, JoinerType joinerType,
Function<E, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new QuadFunction[] { leftMapping };
}
private <Property_> DefaultPentaJoiner(QuadFunction<A, B, C, D, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<E, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C, D, E> DefaultPentaJoiner<A, B, C, D, E> merge(List<DefaultPentaJoiner<A, B, C, D, E>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultPentaJoiner::and);
}
@Override
public DefaultPentaJoiner<A, B, C, D, E> and(PentaJoiner<A, B, C, D, E> otherJoiner) {
DefaultPentaJoiner<A, B, C, D, E> castJoiner = (DefaultPentaJoiner<A, B, C, D, E>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
QuadFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoinerCount; i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultPentaJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public QuadFunction<A, B, C, D, Object> getLeftMapping(int index) {
return (QuadFunction<A, B, C, D, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c, D d, E e) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b, c, d);
Object rightMapping = getRightMapping(i).apply(e);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (o instanceof DefaultPentaJoiner<?, ?, ?, ?, ?> other) {
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/penta/FilteringPentaJoiner.java | package ai.timefold.solver.constraint.streams.common.penta;
import java.util.Objects;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
public final class FilteringPentaJoiner<A, B, C, D, E> implements PentaJoiner<A, B, C, D, E> {
private final PentaPredicate<A, B, C, D, E> filter;
public FilteringPentaJoiner(PentaPredicate<A, B, C, D, E> filter) {
this.filter = filter;
}
@Override
public FilteringPentaJoiner<A, B, C, D, E> and(PentaJoiner<A, B, C, D, E> otherJoiner) {
FilteringPentaJoiner<A, B, C, D, E> castJoiner = (FilteringPentaJoiner<A, B, C, D, E>) otherJoiner;
return new FilteringPentaJoiner<>(filter.and(castJoiner.getFilter()));
}
public PentaPredicate<A, B, C, D, E> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof FilteringPentaJoiner)) {
return false;
}
FilteringPentaJoiner<?, ?, ?, ?, ?> other = (FilteringPentaJoiner<?, ?, ?, ?, ?>) o;
return Objects.equals(filter, other.filter);
}
@Override
public int hashCode() {
return Objects.hash(filter);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/penta/PentaJoinerComber.java | package ai.timefold.solver.constraint.streams.common.penta;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
/**
* Combs an array of {@link PentaJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
* @param <C>
* @param <D>
* @param <E>
*/
public final class PentaJoinerComber<A, B, C, D, E> {
public static <A, B, C, D, E> PentaJoinerComber<A, B, C, D, E> comb(PentaJoiner<A, B, C, D, E>[] joiners) {
List<DefaultPentaJoiner<A, B, C, D, E>> defaultJoinerList = new ArrayList<>(joiners.length);
List<PentaPredicate<A, B, C, D, E>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
PentaJoiner<A, B, C, D, E> joiner = joiners[i];
if (joiner instanceof FilteringPentaJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringPentaJoiner<A, B, C, D, E>) joiner).getFilter());
} else if (joiner instanceof DefaultPentaJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultPentaJoiner<A, B, C, D, E>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultPentaJoiner<A, B, C, D, E> mergedJoiner = DefaultPentaJoiner.merge(defaultJoinerList);
PentaPredicate<A, B, C, D, E> mergedFiltering = mergeFiltering(filteringList);
return new PentaJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <A, B, C, D, E> PentaPredicate<A, B, C, D, E>
mergeFiltering(List<PentaPredicate<A, B, C, D, E>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c, D d, E e) -> {
for (PentaPredicate<A, B, C, D, E> predicate : filteringList) {
if (!predicate.test(a, b, c, d, e)) {
return false;
}
}
return true;
};
}
}
private final DefaultPentaJoiner<A, B, C, D, E> mergedJoiner;
private final PentaPredicate<A, B, C, D, E> mergedFiltering;
public PentaJoinerComber(DefaultPentaJoiner<A, B, C, D, E> mergedJoiner, PentaPredicate<A, B, C, D, E> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultPentaJoiner<A, B, C, D, E> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public PentaPredicate<A, B, C, D, E> getMergedFiltering() {
return mergedFiltering;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/quad/DefaultQuadJoiner.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultQuadJoiner<A, B, C, D> extends AbstractJoiner<D> implements QuadJoiner<A, B, C, D> {
private static final DefaultQuadJoiner NONE =
new DefaultQuadJoiner(new TriFunction[0], new JoinerType[0], new Function[0]);
private final TriFunction<A, B, C, ?>[] leftMappings;
public <Property_> DefaultQuadJoiner(TriFunction<A, B, C, Property_> leftMapping, JoinerType joinerType,
Function<D, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new TriFunction[] { leftMapping };
}
private <Property_> DefaultQuadJoiner(TriFunction<A, B, C, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<D, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C, D> DefaultQuadJoiner<A, B, C, D> merge(List<DefaultQuadJoiner<A, B, C, D>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultQuadJoiner::and);
}
@Override
public DefaultQuadJoiner<A, B, C, D> and(QuadJoiner<A, B, C, D> otherJoiner) {
DefaultQuadJoiner<A, B, C, D> castJoiner = (DefaultQuadJoiner<A, B, C, D>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
TriFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoiner.getJoinerCount(); i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultQuadJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public TriFunction<A, B, C, Object> getLeftMapping(int index) {
return (TriFunction<A, B, C, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c, D d) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b, c);
Object rightMapping = getRightMapping(i).apply(d);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (o instanceof DefaultQuadJoiner<?, ?, ?, ?> other) {
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/quad/FilteringQuadJoiner.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
public final class FilteringQuadJoiner<A, B, C, D> implements QuadJoiner<A, B, C, D> {
private final QuadPredicate<A, B, C, D> filter;
public FilteringQuadJoiner(QuadPredicate<A, B, C, D> filter) {
this.filter = filter;
}
@Override
public FilteringQuadJoiner<A, B, C, D> and(QuadJoiner<A, B, C, D> otherJoiner) {
FilteringQuadJoiner<A, B, C, D> castJoiner = (FilteringQuadJoiner<A, B, C, D>) otherJoiner;
return new FilteringQuadJoiner<>(filter.and(castJoiner.getFilter()));
}
public QuadPredicate<A, B, C, D> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof FilteringQuadJoiner)) {
return false;
}
FilteringQuadJoiner<?, ?, ?, ?> other = (FilteringQuadJoiner<?, ?, ?, ?>) o;
return Objects.equals(filter, other.filter);
}
@Override
public int hashCode() {
return Objects.hash(getFilter());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/quad/InnerQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collection;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
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.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
public interface InnerQuadConstraintStream<A, B, C, D> extends QuadConstraintStream<A, B, C, D> {
static <A, B, C, D> PentaFunction<A, B, C, D, Score<?>, DefaultConstraintJustification>
createDefaultJustificationMapping() {
return (a, b, c, d, score) -> DefaultConstraintJustification.of(score, a, b, c, d);
}
static <A, B, C, D> QuadFunction<A, B, C, D, Collection<?>> createDefaultIndictedObjectsMapping() {
return Arrays::asList;
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> penalize(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> penalizeLong(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> penalizeBigDecimal(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> penalizeConfigurable(ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> penalizeConfigurableLong(ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?>
penalizeConfigurableBigDecimal(QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> reward(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> rewardLong(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> rewardBigDecimal(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> rewardConfigurable(ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> rewardConfigurableLong(ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?>
rewardConfigurableBigDecimal(QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> impact(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> impactLong(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> impactBigDecimal(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> impactConfigurable(ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> impactConfigurableLong(ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?>
impactConfigurableBigDecimal(QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType);
@Override
default Constraint penalize(String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint penalize(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint reward(String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint reward(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint impact(String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint impact(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/quad/QuadConstraintBuilderImpl.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.util.Collection;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintBuilder;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintBuilder;
public final class QuadConstraintBuilderImpl<A, B, C, D, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements QuadConstraintBuilder<A, B, C, D, Score_> {
private PentaFunction<A, B, C, D, Score_, ConstraintJustification> justificationMapping;
private QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping;
public QuadConstraintBuilderImpl(QuadConstraintConstructor<A, B, C, D, Score_> constraintConstructor,
ScoreImpactType impactType, Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected PentaFunction<A, B, C, D, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> QuadConstraintBuilder<A, B, C, D, Score_> justifyWith(
PentaFunction<A, B, C, D, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("""
Justification mapping already set (%s).
Maybe the constraint calls justifyWith() twice?"""
.formatted(justificationMapping));
}
this.justificationMapping =
(PentaFunction<A, B, C, D, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected QuadFunction<A, B, C, D, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public QuadConstraintBuilder<A, B, C, D, Score_>
indictWith(QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("""
Indicted objects' mapping already set (%s).
Maybe the constraint calls indictWith() twice?"""
.formatted(indictedObjectsMapping));
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/quad/QuadConstraintConstructor.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.util.Collection;
import ai.timefold.solver.constraint.streams.common.ConstraintConstructor;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
@FunctionalInterface
public interface QuadConstraintConstructor<A, B, C, D, Score_ extends Score<Score_>>
extends
ConstraintConstructor<Score_, PentaFunction<A, B, C, D, Score_, Object>, QuadFunction<A, B, C, D, Collection<?>>> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/quad/QuadJoinerComber.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
/**
* Combs an array of {@link QuadJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
* @param <C>
* @param <D>
*/
public final class QuadJoinerComber<A, B, C, D> {
public static <A, B, C, D> QuadJoinerComber<A, B, C, D> comb(QuadJoiner<A, B, C, D>[] joiners) {
List<DefaultQuadJoiner<A, B, C, D>> defaultJoinerList = new ArrayList<>(joiners.length);
List<QuadPredicate<A, B, C, D>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
QuadJoiner<A, B, C, D> joiner = joiners[i];
if (joiner instanceof FilteringQuadJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringQuadJoiner<A, B, C, D>) joiner).getFilter());
} else if (joiner instanceof DefaultQuadJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultQuadJoiner<A, B, C, D>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultQuadJoiner<A, B, C, D> mergedJoiner = DefaultQuadJoiner.merge(defaultJoinerList);
QuadPredicate<A, B, C, D> mergedFiltering = mergeFiltering(filteringList);
return new QuadJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <A, B, C, D> QuadPredicate<A, B, C, D> mergeFiltering(List<QuadPredicate<A, B, C, D>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c, D d) -> {
for (QuadPredicate<A, B, C, D> predicate : filteringList) {
if (!predicate.test(a, b, c, d)) {
return false;
}
}
return true;
};
}
}
private final DefaultQuadJoiner<A, B, C, D> mergedJoiner;
private final QuadPredicate<A, B, C, D> mergedFiltering;
public QuadJoinerComber(DefaultQuadJoiner<A, B, C, D> mergedJoiner, QuadPredicate<A, B, C, D> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultQuadJoiner<A, B, C, D> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public QuadPredicate<A, B, C, D> getMergedFiltering() {
return mergedFiltering;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/tri/DefaultTriJoiner.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultTriJoiner<A, B, C> extends AbstractJoiner<C> implements TriJoiner<A, B, C> {
private static final DefaultTriJoiner NONE =
new DefaultTriJoiner(new BiFunction[0], new JoinerType[0], new Function[0]);
private final BiFunction<A, B, ?>[] leftMappings;
public <Property_> DefaultTriJoiner(BiFunction<A, B, Property_> leftMapping, JoinerType joinerType,
Function<C, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new BiFunction[] { leftMapping };
}
private <Property_> DefaultTriJoiner(BiFunction<A, B, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<C, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C> DefaultTriJoiner<A, B, C> merge(List<DefaultTriJoiner<A, B, C>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultTriJoiner::and);
}
@Override
public DefaultTriJoiner<A, B, C> and(TriJoiner<A, B, C> otherJoiner) {
DefaultTriJoiner<A, B, C> castJoiner = (DefaultTriJoiner<A, B, C>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
BiFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoinerCount; i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultTriJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public BiFunction<A, B, Object> getLeftMapping(int index) {
return (BiFunction<A, B, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b);
Object rightMapping = getRightMapping(i).apply(c);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (o instanceof DefaultTriJoiner<?, ?, ?> other) {
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/tri/FilteringTriJoiner.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
public final class FilteringTriJoiner<A, B, C> implements TriJoiner<A, B, C> {
private final TriPredicate<A, B, C> filter;
public FilteringTriJoiner(TriPredicate<A, B, C> filter) {
this.filter = filter;
}
@Override
public FilteringTriJoiner<A, B, C> and(TriJoiner<A, B, C> otherJoiner) {
FilteringTriJoiner<A, B, C> castJoiner = (FilteringTriJoiner<A, B, C>) otherJoiner;
return new FilteringTriJoiner<>(filter.and(castJoiner.getFilter()));
}
public TriPredicate<A, B, C> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof FilteringTriJoiner)) {
return false;
}
FilteringTriJoiner<?, ?, ?> other = (FilteringTriJoiner<?, ?, ?>) o;
return Objects.equals(filter, other.filter);
}
@Override
public int hashCode() {
return Objects.hash(filter);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/tri/InnerTriConstraintStream.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collection;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
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.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
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.TriConstraintStream;
public interface InnerTriConstraintStream<A, B, C> extends TriConstraintStream<A, B, C> {
static <A, B, C> QuadFunction<A, B, C, Score<?>, DefaultConstraintJustification> createDefaultJustificationMapping() {
return (a, b, c, score) -> DefaultConstraintJustification.of(score, a, b, c);
}
static <A, B, C> TriFunction<A, B, C, Collection<?>> createDefaultIndictedObjectsMapping() {
return Arrays::asList;
}
RetrievalSemantics getRetrievalSemantics();
/**
* This method will return true if the constraint stream is guaranteed to only produce distinct tuples.
* See {@link #distinct()} for details.
*
* @return true if the guarantee of distinct tuples is provided
*/
boolean guaranteesDistinct();
@Override
default <D> QuadConstraintStream<A, B, C, D> join(Class<D> otherClass, QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return join(getConstraintFactory().forEach(otherClass), joiners);
} else {
return join(getConstraintFactory().from(otherClass), joiners);
}
}
@Override
default TriConstraintStream<A, B, C> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy((a, b, c) -> a, (a, b, c) -> b, (a, b, c) -> c);
}
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> penalize(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> penalizeLong(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> penalizeBigDecimal(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default TriConstraintBuilder<A, B, C, ?> penalizeConfigurable(ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default TriConstraintBuilder<A, B, C, ?> penalizeConfigurableLong(ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default TriConstraintBuilder<A, B, C, ?> penalizeConfigurableBigDecimal(TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> reward(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> rewardLong(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> rewardBigDecimal(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default TriConstraintBuilder<A, B, C, ?> rewardConfigurable(ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default TriConstraintBuilder<A, B, C, ?> rewardConfigurableLong(ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default TriConstraintBuilder<A, B, C, ?> rewardConfigurableBigDecimal(TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> impact(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> impactLong(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> impactBigDecimal(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default TriConstraintBuilder<A, B, C, ?> impactConfigurable(ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default TriConstraintBuilder<A, B, C, ?> impactConfigurableLong(ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default TriConstraintBuilder<A, B, C, ?> impactConfigurableBigDecimal(TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher,
ScoreImpactType scoreImpactType);
@Override
default Constraint penalize(String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint penalize(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint reward(String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint reward(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint impact(String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint impact(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/tri/TriConstraintBuilderImpl.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.util.Collection;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintBuilder;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintBuilder;
public final class TriConstraintBuilderImpl<A, B, C, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements TriConstraintBuilder<A, B, C, Score_> {
private QuadFunction<A, B, C, Score_, ConstraintJustification> justificationMapping;
private TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping;
public TriConstraintBuilderImpl(TriConstraintConstructor<A, B, C, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected QuadFunction<A, B, C, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> TriConstraintBuilder<A, B, C, Score_> justifyWith(
QuadFunction<A, B, C, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("""
Justification mapping already set (%s).
Maybe the constraint calls justifyWith() twice?"""
.formatted(justificationMapping));
}
this.justificationMapping =
(QuadFunction<A, B, C, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected TriFunction<A, B, C, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public TriConstraintBuilder<A, B, C, Score_> indictWith(TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("""
Indicted objects' mapping already set (%s).
Maybe the constraint calls indictWith() twice?"""
.formatted(indictedObjectsMapping));
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/tri/TriConstraintConstructor.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.util.Collection;
import ai.timefold.solver.constraint.streams.common.ConstraintConstructor;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
@FunctionalInterface
public interface TriConstraintConstructor<A, B, C, Score_ extends Score<Score_>>
extends ConstraintConstructor<Score_, QuadFunction<A, B, C, Score_, Object>, TriFunction<A, B, C, Collection<?>>> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/tri/TriJoinerComber.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
/**
* Combs an array of {@link TriJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
* @param <C>
*/
public final class TriJoinerComber<A, B, C> {
public static <A, B, C> TriJoinerComber<A, B, C> comb(TriJoiner<A, B, C>[] joiners) {
List<DefaultTriJoiner<A, B, C>> defaultJoinerList = new ArrayList<>(joiners.length);
List<TriPredicate<A, B, C>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
TriJoiner<A, B, C> joiner = joiners[i];
if (joiner instanceof FilteringTriJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringTriJoiner<A, B, C>) joiner).getFilter());
} else if (joiner instanceof DefaultTriJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultTriJoiner<A, B, C>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultTriJoiner<A, B, C> mergedJoiner = DefaultTriJoiner.merge(defaultJoinerList);
TriPredicate<A, B, C> mergedFiltering = mergeFiltering(filteringList);
return new TriJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <A, B, C> TriPredicate<A, B, C> mergeFiltering(List<TriPredicate<A, B, C>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c) -> {
for (TriPredicate<A, B, C> predicate : filteringList) {
if (!predicate.test(a, b, c)) {
return false;
}
}
return true;
};
}
}
private final DefaultTriJoiner<A, B, C> mergedJoiner;
private final TriPredicate<A, B, C> mergedFiltering;
public TriJoinerComber(DefaultTriJoiner<A, B, C> mergedJoiner, TriPredicate<A, B, C> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultTriJoiner<A, B, C> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public TriPredicate<A, B, C> getMergedFiltering() {
return mergedFiltering;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/uni/InnerUniConstraintStream.java | package ai.timefold.solver.constraint.streams.common.uni;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.Collections;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.constraint.streams.common.bi.BiJoinerComber;
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.ConstraintFactory;
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.uni.UniConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
public interface InnerUniConstraintStream<A> extends UniConstraintStream<A> {
static <A> BiFunction<A, Score<?>, DefaultConstraintJustification> createDefaultJustificationMapping() {
return (a, score) -> DefaultConstraintJustification.of(score, a);
}
static <A> Function<A, Collection<?>> createDefaultIndictedObjectsMapping() {
return Collections::singletonList;
}
RetrievalSemantics getRetrievalSemantics();
/**
* This method returns true if the constraint stream is guaranteed to only produce distinct tuples.
* See {@link #distinct()} for details.
*
* @return true if the guarantee of distinct tuples is provided
*/
boolean guaranteesDistinct();
@Override
default <B> BiConstraintStream<A, B> join(Class<B> otherClass, BiJoiner<A, B>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return join(getConstraintFactory().forEach(otherClass), joiners);
} else {
return join(getConstraintFactory().from(otherClass), joiners);
}
}
/**
* Allows {@link ConstraintFactory#forEachUniquePair(Class)} to reuse the joiner combing logic.
*
* @param otherStream never null
* @param joinerComber never null
* @param <B>
* @return never null
*/
<B> BiConstraintStream<A, B> join(UniConstraintStream<B> otherStream, BiJoinerComber<A, B> joinerComber);
@Override
default UniConstraintStream<A> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(Function.identity());
}
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> penalize(Score_ constraintWeight,
ToIntFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> penalizeLong(Score_ constraintWeight,
ToLongFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> penalizeBigDecimal(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default UniConstraintBuilder<A, ?> penalizeConfigurable(ToIntFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default UniConstraintBuilder<A, ?> penalizeConfigurableLong(ToLongFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default UniConstraintBuilder<A, ?> penalizeConfigurableBigDecimal(Function<A, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> reward(Score_ constraintWeight,
ToIntFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> rewardLong(Score_ constraintWeight,
ToLongFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> rewardBigDecimal(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default UniConstraintBuilder<A, ?> rewardConfigurable(ToIntFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default UniConstraintBuilder<A, ?> rewardConfigurableLong(ToLongFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default UniConstraintBuilder<A, ?> rewardConfigurableBigDecimal(Function<A, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> impact(Score_ constraintWeight,
ToIntFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> impactLong(Score_ constraintWeight,
ToLongFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> impactBigDecimal(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default UniConstraintBuilder<A, ?> impactConfigurable(ToIntFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default UniConstraintBuilder<A, ?> impactConfigurableLong(ToLongFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default UniConstraintBuilder<A, ?> impactConfigurableBigDecimal(Function<A, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToIntFunction<A> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToLongFunction<A> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType);
@Override
default Constraint penalize(String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint penalize(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint reward(String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint reward(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint impact(String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint impact(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/uni/UniConstraintBuilderImpl.java | package ai.timefold.solver.constraint.streams.common.uni;
import java.util.Collection;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintBuilder;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintBuilder;
public final class UniConstraintBuilderImpl<A, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements UniConstraintBuilder<A, Score_> {
private BiFunction<A, Score_, ConstraintJustification> justificationMapping;
private Function<A, Collection<Object>> indictedObjectsMapping;
public UniConstraintBuilderImpl(UniConstraintConstructor<A, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected BiFunction<A, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> UniConstraintBuilder<A, Score_> justifyWith(
BiFunction<A, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("""
Justification mapping already set (%s).
Maybe the constraint calls justifyWith() twice?"""
.formatted(justificationMapping));
}
this.justificationMapping =
(BiFunction<A, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected Function<A, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public UniConstraintBuilder<A, Score_> indictWith(Function<A, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("""
Indicted objects' mapping already set (%s).
Maybe the constraint calls indictWith() twice?"""
.formatted(indictedObjectsMapping));
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/uni/UniConstraintConstructor.java | package ai.timefold.solver.constraint.streams.common.uni;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.ConstraintConstructor;
import ai.timefold.solver.core.api.score.Score;
@FunctionalInterface
public interface UniConstraintConstructor<A, Score_ extends Score<Score_>>
extends ConstraintConstructor<Score_, BiFunction<A, Score_, Object>, Function<A, Collection<?>>> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/BavetConstraint.java | package ai.timefold.solver.constraint.streams.bavet;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.score.Score;
public final class BavetConstraint<Solution_>
extends AbstractConstraint<Solution_, BavetConstraint<Solution_>, BavetConstraintFactory<Solution_>> {
private final BavetScoringConstraintStream<Solution_> scoringConstraintStream;
public BavetConstraint(BavetConstraintFactory<Solution_> constraintFactory, String constraintPackage,
String constraintName, Function<Solution_, Score<?>> constraintWeightExtractor,
ScoreImpactType scoreImpactType, Object justificationMapping, Object indictedObjectsMapping,
boolean isConstraintWeightConfigurable, BavetScoringConstraintStream<Solution_> scoringConstraintStream) {
super(constraintFactory, constraintPackage, constraintName, constraintWeightExtractor, scoreImpactType,
isConstraintWeightConfigurable, justificationMapping, indictedObjectsMapping);
this.scoringConstraintStream = scoringConstraintStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public String toString() {
return "BavetConstraint(" + getConstraintId() + ")";
}
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
scoringConstraintStream.collectActiveConstraintStreams(constraintStreamSet);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/BavetConstraintFactory.java | package ai.timefold.solver.constraint.streams.bavet;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetForEachUniConstraintStream;
import ai.timefold.solver.constraint.streams.common.InnerConstraintFactory;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.domain.constraintweight.descriptor.ConstraintConfigurationDescriptor;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
public final class BavetConstraintFactory<Solution_>
extends InnerConstraintFactory<Solution_, BavetConstraint<Solution_>> {
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);
ConstraintConfigurationDescriptor<Solution_> configurationDescriptor = solutionDescriptor
.getConstraintConfigurationDescriptor();
if (configurationDescriptor == null) {
Package pack = solutionDescriptor.getSolutionClass().getPackage();
defaultConstraintPackage = (pack == null) ? "" : pack.getName();
} else {
defaultConstraintPackage = configurationDescriptor.getConstraintPackage();
}
}
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 by the old copy.
* {@link BavetAbstractConstraintStream} implement equals/hashcode ignoring child streams.
* <p>
* {@link BavetConstraintSessionFactory#buildSession(boolean, Object)} relies on this occurring 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
// ************************************************************************
@Override
public <A> UniConstraintStream<A> forEachIncludingNullVars(Class<A> sourceClass) {
assertValidFromType(sourceClass);
return share(new BavetForEachUniConstraintStream<>(this, sourceClass, RetrievalSemantics.STANDARD));
}
@Override
public <A> BavetAbstractUniConstraintStream<Solution_, A> fromUnfiltered(Class<A> fromClass) {
assertValidFromType(fromClass);
return share(new BavetForEachUniConstraintStream<>(this, fromClass, RetrievalSemantics.LEGACY));
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return solutionDescriptor;
}
public EnvironmentMode getEnvironmentMode() {
return environmentMode;
}
@Override
public String getDefaultConstraintPackage() {
return defaultConstraintPackage;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/BavetConstraintSession.java | package ai.timefold.solver.constraint.streams.bavet;
import java.util.IdentityHashMap;
import java.util.Map;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractNode;
import ai.timefold.solver.constraint.streams.bavet.uni.ForEachUniNode;
import ai.timefold.solver.constraint.streams.common.inliner.AbstractScoreInliner;
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;
final class BavetConstraintSession<Score_ extends Score<Score_>> {
private final AbstractScoreInliner<Score_> scoreInliner;
private final Map<Class<?>, ForEachUniNode<Object>> declaredClassToNodeMap;
private final AbstractNode[] nodes; // Indexed by nodeIndex
private final Map<Class<?>, ForEachUniNode<Object>[]> effectiveClassToNodeArrayMap;
public BavetConstraintSession(AbstractScoreInliner<Score_> scoreInliner,
Map<Class<?>, ForEachUniNode<Object>> declaredClassToNodeMap,
AbstractNode[] nodes) {
this.scoreInliner = scoreInliner;
this.declaredClassToNodeMap = declaredClassToNodeMap;
this.nodes = nodes;
this.effectiveClassToNodeArrayMap = new IdentityHashMap<>(declaredClassToNodeMap.size());
}
public void insert(Object fact) {
Class<?> factClass = fact.getClass();
for (ForEachUniNode<Object> node : findNodes(factClass)) {
node.insert(fact);
}
}
private ForEachUniNode<Object>[] findNodes(Class<?> factClass) {
// Map.computeIfAbsent() would have created lambdas on the hot path, this will not.
ForEachUniNode<Object>[] nodeArray = effectiveClassToNodeArrayMap.get(factClass);
if (nodeArray == null) {
nodeArray = declaredClassToNodeMap.entrySet()
.stream()
.filter(entry -> entry.getKey().isAssignableFrom(factClass))
.map(Map.Entry::getValue)
.toArray(ForEachUniNode[]::new);
effectiveClassToNodeArrayMap.put(factClass, nodeArray);
}
return nodeArray;
}
public void update(Object fact) {
Class<?> factClass = fact.getClass();
for (ForEachUniNode<Object> node : findNodes(factClass)) {
node.update(fact);
}
}
public void retract(Object fact) {
Class<?> factClass = fact.getClass();
for (ForEachUniNode<Object> node : findNodes(factClass)) {
node.retract(fact);
}
}
public Score_ calculateScore(int initScore) {
for (AbstractNode node : nodes) {
node.calculateScore();
}
return scoreInliner.extractScore(initScore);
}
public AbstractScoreInliner<Score_> getScoreInliner() {
return scoreInliner;
}
public Map<String, ConstraintMatchTotal<Score_>> getConstraintMatchTotalMap() {
return scoreInliner.getConstraintMatchTotalMap();
}
public Map<Object, Indictment<Score_>> getIndictmentMap() {
return scoreInliner.getIndictmentMap();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/BavetConstraintSessionFactory.java | package ai.timefold.solver.constraint.streams.bavet;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.uni.ForEachUniNode;
import ai.timefold.solver.constraint.streams.common.inliner.AbstractScoreInliner;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.definition.ScoreDefinition;
public final class BavetConstraintSessionFactory<Solution_, Score_ extends Score<Score_>> {
private final SolutionDescriptor<Solution_> solutionDescriptor;
private final List<BavetConstraint<Solution_>> constraintList;
public BavetConstraintSessionFactory(SolutionDescriptor<Solution_> solutionDescriptor,
List<BavetConstraint<Solution_>> constraintList) {
this.solutionDescriptor = solutionDescriptor;
this.constraintList = constraintList;
}
// ************************************************************************
// Node creation
// ************************************************************************
public BavetConstraintSession<Score_> buildSession(boolean constraintMatchEnabled,
Solution_ workingSolution) {
ScoreDefinition<Score_> scoreDefinition = solutionDescriptor.getScoreDefinition();
AbstractScoreInliner<Score_> scoreInliner = AbstractScoreInliner.buildScoreInliner(scoreDefinition,
constraintMatchEnabled);
Score_ zeroScore = scoreDefinition.getZeroScore();
Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet = new LinkedHashSet<>();
Map<Constraint, Score_> constraintWeightMap = new HashMap<>(constraintList.size());
for (BavetConstraint<Solution_> constraint : constraintList) {
Score_ constraintWeight = constraint.extractConstraintWeight(workingSolution);
// Filter out nodes that only lead to constraints with zero weight.
// Note: Node sharing happens earlier, in BavetConstraintFactory#share(Stream_).
if (!constraintWeight.equals(zeroScore)) {
// 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).
constraint.collectActiveConstraintStreams(constraintStreamSet);
constraintWeightMap.put(constraint, constraintWeight);
}
}
NodeBuildHelper<Score_> buildHelper = new NodeBuildHelper<>(constraintStreamSet, constraintWeightMap, scoreInliner);
// Build constraintStreamSet in reverse order to create downstream nodes first
// so every node only has final variables (some of which have downstream node method references).
List<BavetAbstractConstraintStream<Solution_>> reversedConstraintStreamList = new ArrayList<>(constraintStreamSet);
Collections.reverse(reversedConstraintStreamList);
for (BavetAbstractConstraintStream<Solution_> constraintStream : reversedConstraintStreamList) {
constraintStream.buildNode(buildHelper);
}
List<AbstractNode> nodeList = buildHelper.destroyAndGetNodeList();
Map<Class<?>, ForEachUniNode<Object>> declaredClassToNodeMap = new LinkedHashMap<>();
long nextNodeId = 0;
for (AbstractNode node : nodeList) {
node.setId(nextNodeId++);
if (node instanceof ForEachUniNode) {
ForEachUniNode<Object> forEachUniNode = (ForEachUniNode<Object>) node;
ForEachUniNode<Object> old = declaredClassToNodeMap.put(forEachUniNode.getForEachClass(), forEachUniNode);
if (old != null) {
throw new IllegalStateException("Impossible state: For class (" + forEachUniNode.getForEachClass()
+ ") there are 2 nodes (" + forEachUniNode + ", " + old + ").");
}
}
}
return new BavetConstraintSession<>(scoreInliner, declaredClassToNodeMap, nodeList.toArray(new AbstractNode[0]));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/BavetConstraintStreamScoreDirector.java | package ai.timefold.solver.constraint.streams.bavet;
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.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.VariableDescriptor;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirector;
/**
* 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_>> {
protected BavetConstraintSession<Score_> session;
public BavetConstraintStreamScoreDirector(
BavetConstraintStreamScoreDirectorFactory<Solution_, Score_> scoreDirectorFactory,
boolean lookUpEnabled, boolean constraintMatchEnabledPreference) {
super(scoreDirectorFactory, lookUpEnabled, constraintMatchEnabledPreference);
}
// ************************************************************************
// Complex methods
// ************************************************************************
@Override
public void setWorkingSolution(Solution_ workingSolution) {
super.setWorkingSolution(workingSolution);
resetConstraintStreamingSession();
}
private void resetConstraintStreamingSession() {
session = scoreDirectorFactory.newSession(constraintMatchEnabledPreference, workingSolution);
getSolutionDescriptor().visitAll(workingSolution, session::insert);
}
@Override
public Score_ calculateScore() {
variableListenerSupport.assertNotificationQueuesAreEmpty();
Score_ score = session.calculateScore(workingInitScore);
setCalculatedScore(score);
return score;
}
@Override
public boolean isConstraintMatchEnabled() {
return constraintMatchEnabledPreference;
}
@Override
public Map<String, ConstraintMatchTotal<Score_>> getConstraintMatchTotalMap() {
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 (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();
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 (" + entity + ") cannot be added to the ScoreDirector.");
}
if (!getSolutionDescriptor().hasEntityDescriptor(entity.getClass())) {
throw new IllegalArgumentException("The entity (" + entity + ") of class (" + entity.getClass()
+ ") is not a configured @" + 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 (" + problemFact + ") cannot be added to the ScoreDirector.");
}
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);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
public BavetConstraintSession<Score_> getSession() {
return session;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/BavetConstraintStreamScoreDirectorFactory.java | package ai.timefold.solver.constraint.streams.bavet;
import java.util.Arrays;
import java.util.List;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintStreamScoreDirectorFactory;
import ai.timefold.solver.constraint.streams.common.inliner.AbstractScoreInliner;
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.ConstraintProvider;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
public final class BavetConstraintStreamScoreDirectorFactory<Solution_, Score_ extends Score<Score_>>
extends AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_> {
private final BavetConstraintSessionFactory<Solution_, Score_> constraintSessionFactory;
private final List<BavetConstraint<Solution_>> constraintList;
public BavetConstraintStreamScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor,
ConstraintProvider constraintProvider, EnvironmentMode environmentMode) {
super(solutionDescriptor);
BavetConstraintFactory<Solution_> constraintFactory = new BavetConstraintFactory<>(solutionDescriptor, environmentMode);
constraintList = constraintFactory.buildConstraints(constraintProvider);
constraintSessionFactory = new BavetConstraintSessionFactory<>(solutionDescriptor, constraintList);
}
@Override
public BavetConstraintStreamScoreDirector<Solution_, Score_> buildScoreDirector(boolean lookUpEnabled,
boolean constraintMatchEnabledPreference) {
return new BavetConstraintStreamScoreDirector<>(this, lookUpEnabled, constraintMatchEnabledPreference);
}
public BavetConstraintSession<Score_> newSession(boolean constraintMatchEnabled, Solution_ workingSolution) {
return constraintSessionFactory.buildSession(constraintMatchEnabled, workingSolution);
}
@Override
public AbstractScoreInliner<Score_> fireAndForget(Object... facts) {
BavetConstraintSession<Score_> session = newSession(true, null);
Arrays.stream(facts).forEach(session::insert);
session.calculateScore(0);
return session.getScoreInliner();
}
@Override
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return solutionDescriptor;
}
@Override
public Constraint[] getConstraints() {
return constraintList.toArray(new Constraint[0]);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/BavetConstraintStreamScoreDirectorFactoryService.java | package ai.timefold.solver.constraint.streams.bavet;
import static ai.timefold.solver.core.api.score.stream.ConstraintStreamImplType.DROOLS;
import java.util.Objects;
import java.util.function.Supplier;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintStreamScoreDirectorFactory;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintStreamScoreDirectorFactoryService;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
import ai.timefold.solver.core.api.score.stream.ConstraintStreamImplType;
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.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.director.ScoreDirectorType;
public final class BavetConstraintStreamScoreDirectorFactoryService<Solution_, Score_ extends Score<Score_>>
extends AbstractConstraintStreamScoreDirectorFactoryService<Solution_, Score_> {
@Override
public int getPriority() {
return Integer.MIN_VALUE;
}
@Override
public ScoreDirectorType getSupportedScoreDirectorType() {
return ScoreDirectorType.CONSTRAINT_STREAMS;
}
@Override
public Supplier<AbstractScoreDirectorFactory<Solution_, Score_>> buildScoreDirectorFactory(ClassLoader classLoader,
SolutionDescriptor<Solution_> solutionDescriptor, ScoreDirectorFactoryConfig config,
EnvironmentMode environmentMode) {
ConstraintStreamImplType constraintStreamImplType_ =
Objects.requireNonNullElse(config.getConstraintStreamImplType(), ConstraintStreamImplType.BAVET);
if (constraintStreamImplType_ == DROOLS) {
return null;
}
if (config.getConstraintProviderClass() != null) {
if (!ConstraintProvider.class.isAssignableFrom(config.getConstraintProviderClass())) {
throw new IllegalArgumentException(
"The constraintProviderClass (" + config.getConstraintProviderClass()
+ ") does not implement " + ConstraintProvider.class.getSimpleName() + ".");
}
return () -> {
ConstraintProvider constraintProvider = ConfigUtils.newInstance(config,
"constraintProviderClass", config.getConstraintProviderClass());
ConfigUtils.applyCustomProperties(constraintProvider, "constraintProviderClass",
config.getConstraintProviderCustomProperties(), "constraintProviderCustomProperties");
return buildScoreDirectorFactory(solutionDescriptor, constraintProvider, environmentMode);
};
} else {
if (config.getConstraintProviderCustomProperties() != null) {
throw new IllegalStateException("If there is no constraintProviderClass (" + config.getConstraintProviderClass()
+ "), then there can be no constraintProviderCustomProperties ("
+ config.getConstraintProviderCustomProperties() + ") either.");
}
return null;
}
}
@Override
public boolean supportsImplType(ConstraintStreamImplType constraintStreamImplType) {
return constraintStreamImplType == ConstraintStreamImplType.BAVET;
}
@Override
public AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_> buildScoreDirectorFactory(
SolutionDescriptor<Solution_> solutionDescriptor, ConstraintProvider constraintProvider,
EnvironmentMode environmentMode) {
return new BavetConstraintStreamScoreDirectorFactory<>(solutionDescriptor, constraintProvider, environmentMode);
}
@Override
public ConstraintFactory buildConstraintFactory(SolutionDescriptor<Solution_> solutionDescriptor,
EnvironmentMode environmentMode) {
return new BavetConstraintFactory<>(solutionDescriptor, environmentMode);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/AbstractGroupBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractGroupNode;
import ai.timefold.solver.constraint.streams.bavet.common.Tuple;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
abstract class AbstractGroupBiNode<OldA, OldB, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_, GroupKey_, ResultContainer_, Result_>
extends AbstractGroupNode<BiTuple<OldA, OldB>, OutTuple_, MutableOutTuple_, GroupKey_, ResultContainer_, Result_> {
private final TriFunction<ResultContainer_, OldA, OldB, Runnable> accumulator;
protected AbstractGroupBiNode(int groupStoreIndex, int undoStoreIndex,
Function<BiTuple<OldA, OldB>, GroupKey_> groupKeyFunction,
BiConstraintCollector<OldA, OldB, ResultContainer_, Result_> collector,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, groupKeyFunction,
collector == null ? null : collector.supplier(),
collector == null ? null : collector.finisher(),
nextNodesTupleLifecycle, environmentMode);
accumulator = collector == null ? null : collector.accumulator();
}
protected AbstractGroupBiNode(int groupStoreIndex, Function<BiTuple<OldA, OldB>, GroupKey_> groupKeyFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
super(groupStoreIndex, groupKeyFunction, nextNodesTupleLifecycle, environmentMode);
accumulator = null;
}
@Override
protected final Runnable accumulate(ResultContainer_ resultContainer, BiTuple<OldA, OldB> tuple) {
return accumulator.apply(resultContainer, tuple.getFactA(), tuple.getFactB());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetAbstractBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.of;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
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.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetGroupQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetGroupTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetJoinTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetGroupUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetIfExistsBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetJoinBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetMapUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.constraint.streams.common.bi.BiConstraintBuilderImpl;
import ai.timefold.solver.constraint.streams.common.bi.InnerBiConstraintStream;
import ai.timefold.solver.constraint.streams.common.tri.TriJoinerComber;
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;
public abstract class BavetAbstractBiConstraintStream<Solution_, A, B> extends BavetAbstractConstraintStream<Solution_>
implements InnerBiConstraintStream<A, B> {
protected final List<BavetAbstractBiConstraintStream<Solution_, A, B>> childStreamList = new ArrayList<>(2);
public BavetAbstractBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
public List<BavetAbstractBiConstraintStream<Solution_, A, B>> getChildStreamList() {
return childStreamList;
}
// ************************************************************************
// Stream builder methods
// ************************************************************************
public <Stream_ extends BavetAbstractBiConstraintStream<Solution_, A, B>> Stream_ shareAndAddChild(
Stream_ stream) {
return constraintFactory.share(stream, childStreamList::add);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public BavetAbstractBiConstraintStream<Solution_, A, B> filter(BiPredicate<A, B> predicate) {
return shareAndAddChild(
new BavetFilterBiConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// Join
// ************************************************************************
@Override
@SafeVarargs
public final <C> TriConstraintStream<A, B, C> join(UniConstraintStream<C> otherStream,
TriJoiner<A, B, C>... joiners) {
BavetAbstractUniConstraintStream<Solution_, C> other = assertBavetUniConstraintStream(otherStream);
TriJoinerComber<A, B, C> joinerComber = TriJoinerComber.comb(joiners);
BavetJoinBridgeBiConstraintStream<Solution_, A, B> leftBridge =
new BavetJoinBridgeBiConstraintStream<>(constraintFactory, this, true);
BavetJoinBridgeUniConstraintStream<Solution_, C> rightBridge =
new BavetJoinBridgeUniConstraintStream<>(constraintFactory, other, false);
BavetJoinTriConstraintStream<Solution_, A, B, C> joinStream =
new BavetJoinTriConstraintStream<>(constraintFactory, leftBridge, rightBridge,
joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering());
leftBridge.setJoinStream(joinStream);
rightBridge.setJoinStream(joinStream);
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 <C> BiConstraintStream<A, B> ifExists(Class<C> otherClass, TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
@Override
public final <C> BiConstraintStream<A, B> ifExistsIncludingNullVars(Class<C> otherClass, TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEachIncludingNullVars(otherClass), joiners);
} else {
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <C> BiConstraintStream<A, B> ifExists(UniConstraintStream<C> otherStream, TriJoiner<A, B, C>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final <C> BiConstraintStream<A, B> ifNotExists(Class<C> otherClass, TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
@Override
public final <C> BiConstraintStream<A, B> ifNotExistsIncludingNullVars(Class<C> otherClass, TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEachIncludingNullVars(otherClass), joiners);
} else {
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <C> BiConstraintStream<A, B> ifNotExists(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) {
BavetAbstractUniConstraintStream<Solution_, C> other = assertBavetUniConstraintStream(otherStream);
TriJoinerComber<A, B, C> joinerComber = TriJoinerComber.comb(joiners);
BavetIfExistsBridgeUniConstraintStream<Solution_, C> parentBridgeC = other.shareAndAddChild(
new BavetIfExistsBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsBiConstraintStream<>(constraintFactory, this, parentBridgeC,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
BiConstraintCollector<A, B, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group0Mapping1CollectorBiNode<>(groupStoreIndex, undoStoreIndex,
collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
BavetUniGroupBridgeBiConstraintStream<Solution_, A, B, NewA> bridge = shareAndAddChild(
new BavetUniGroupBridgeBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupUniConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
BiConstraintCollector<A, B, ResultContainerA_, ResultA_> collectorA,
BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group0Mapping2CollectorBiNode<>(groupStoreIndex, undoStoreIndex,
collectorA, collectorB, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
BavetBiGroupBridgeBiConstraintStream<Solution_, A, B, NewA, NewB> bridge = shareAndAddChild(
new BavetBiGroupBridgeBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupBiConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(BiConstraintCollector<A, B, ResultContainerA_, ResultA_> collectorA,
BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex,
tupleLifecycle, outputStoreSize, environmentMode) -> new Group0Mapping3CollectorBiNode<>(groupStoreIndex,
undoStoreIndex, collectorA, collectorB, collectorC, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
BavetTriGroupBridgeBiConstraintStream<Solution_, A, B, NewA, NewB, NewC> bridge = shareAndAddChild(
new BavetTriGroupBridgeBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupTriConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(BiConstraintCollector<A, B, ResultContainerA_, ResultA_> collectorA,
BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC,
BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group0Mapping4CollectorBiNode<>(groupStoreIndex, undoStoreIndex, collectorA,
collectorB, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
BavetQuadGroupBridgeBiConstraintStream<Solution_, A, B, NewA, NewB, NewC, NewD> bridge = shareAndAddChild(
new BavetQuadGroupBridgeBiConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupQuadConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(BiFunction<A, B, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group1Mapping0CollectorBiNode<>(
groupKeyMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_> groupBy(BiFunction<A, B, GroupKey_> groupKeyMapping,
BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping2CollectorBiNode<>(groupKeyMapping, groupStoreIndex,
undoStoreIndex, collectorB, collectorC, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(BiFunction<A, B, GroupKey_> groupKeyMapping,
BiConstraintCollector<A, B, ResultContainerB_, ResultB_> collectorB,
BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC,
BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping3CollectorBiNode<>(groupKeyMapping, groupStoreIndex,
undoStoreIndex, collectorB, collectorC, collectorD, tupleLifecycle, outputStoreSize,
environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
BiFunction<A, B, GroupKey_> groupKeyMapping,
BiConstraintCollector<A, B, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group1Mapping1CollectorBiNode<>(groupKeyMapping, groupStoreIndex,
undoStoreIndex, collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
BiFunction<A, B, GroupKeyA_> groupKeyAMapping, BiFunction<A, B, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group2Mapping0CollectorBiNode<>(
groupKeyAMapping, groupKeyBMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_> groupBy(
BiFunction<A, B, GroupKeyA_> groupKeyAMapping, BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
BiConstraintCollector<A, B, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping1CollectorBiNode<>(groupKeyAMapping, groupKeyBMapping,
groupStoreIndex, undoStoreIndex, collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
BiFunction<A, B, GroupKeyA_> groupKeyAMapping, BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
BiConstraintCollector<A, B, ResultContainerC_, ResultC_> collectorC,
BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping2CollectorBiNode<>(groupKeyAMapping, groupKeyBMapping, groupStoreIndex,
undoStoreIndex, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
BiFunction<A, B, GroupKeyA_> groupKeyAMapping, BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
BiFunction<A, B, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor = of((groupStoreIndex,
tupleLifecycle, outputStoreSize, environmentMode) -> new Group3Mapping0CollectorBiNode<>(groupKeyAMapping,
groupKeyBMapping, groupKeyCMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(BiFunction<A, B, GroupKeyA_> groupKeyAMapping, BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
BiFunction<A, B, GroupKeyC_> groupKeyCMapping,
BiConstraintCollector<A, B, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group3Mapping1CollectorBiNode<>(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping,
groupStoreIndex, undoStoreIndex, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(BiFunction<A, B, GroupKeyA_> groupKeyAMapping, BiFunction<A, B, GroupKeyB_> groupKeyBMapping,
BiFunction<A, B, GroupKeyC_> groupKeyCMapping, BiFunction<A, B, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group4Mapping0CollectorBiNode<>(
groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping, groupStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public <ResultA_> UniConstraintStream<ResultA_> map(BiFunction<A, B, ResultA_> mapping) {
BavetMapBridgeBiConstraintStream<Solution_, A, B, ResultA_> bridge = shareAndAddChild(
new BavetMapBridgeBiConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetMapUniConstraintStream<>(constraintFactory, bridge),
bridge::setMapStream);
}
@Override
public <ResultB_> BiConstraintStream<A, ResultB_> flattenLast(Function<B, Iterable<ResultB_>> mapping) {
BavetFlattenLastBridgeBiConstraintStream<Solution_, A, B, ResultB_> bridge = shareAndAddChild(
new BavetFlattenLastBridgeBiConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetFlattenLastBiConstraintStream<>(constraintFactory, bridge),
bridge::setFlattenLastStream);
}
// ************************************************************************
// 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, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName, 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 InnerBiConstraintStream.createDefaultJustificationMapping();
}
@Override
protected final BiFunction<A, B, Collection<?>> getDefaultIndictedObjectsMapping() {
return InnerBiConstraintStream.createDefaultIndictedObjectsMapping();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetBiGroupBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetBiGroupBridgeBiConstraintStream<Solution_, A, B, NewA, NewB>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetFilterBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiPredicate;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetFilterBiConstraintStream<Solution_, A, B> extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private final BiPredicate<A, B> predicate;
public BavetFilterBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
BiPredicate<A, B> predicate) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
buildHelper.<BiTuple<A, B>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalBiTupleLifecycle<>(predicate, tupleLifecycle));
}
// ************************************************************************
// 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) {
BavetFilterBiConstraintStream<?, ?, ?> other = (BavetFilterBiConstraintStream<?, ?, ?>) o;
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-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetFlattenLastBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetFlattenLastBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetFlattenLastBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetFlattenLastBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "FlattenLast() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetFlattenLastBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetFlattenLastBridgeBiConstraintStream<Solution_, A, B, NewB>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private final Function<B, Iterable<NewB>> mappingFunction;
private BavetFlattenLastBiConstraintStream<Solution_, A, NewB> flattenLastStream;
public BavetFlattenLastBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
Function<B, Iterable<NewB>> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setFlattenLastStream(BavetFlattenLastBiConstraintStream<Solution_, A, NewB> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has an non-empty childStreamList (" + childStreamList + ") but it's a flattenLast bridge.");
}
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
// ************************************************************************
// TODO
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetGroupBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetGroupBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetGroupBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetGroupBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "Group() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetIfExistsBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractIfExistsNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory;
import ai.timefold.solver.constraint.streams.bavet.common.index.JoinerUtils;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetIfExistsBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.common.tri.DefaultTriJoiner;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
public final class BavetIfExistsBiConstraintStream<Solution_, A, B, C>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parentAB;
private final BavetIfExistsBridgeUniConstraintStream<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,
BavetIfExistsBridgeUniConstraintStream<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(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractIfExistsNode<BiTuple<A, B>, C> node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsBiNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentAB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeC.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsBiNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
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, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
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, parentBridgeC);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetJoinBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiPredicate;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory;
import ai.timefold.solver.constraint.streams.bavet.common.index.JoinerUtils;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetJoinBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.constraint.streams.common.bi.DefaultBiJoiner;
import ai.timefold.solver.core.api.score.Score;
public final class BavetJoinBiConstraintStream<Solution_, A, B> extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements BavetJoinConstraintStream<Solution_> {
private final BavetJoinBridgeUniConstraintStream<Solution_, A> leftParent;
private final BavetJoinBridgeUniConstraintStream<Solution_, B> rightParent;
private final DefaultBiJoiner<A, B> joiner;
private final BiPredicate<A, B> filtering;
public BavetJoinBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetJoinBridgeUniConstraintStream<Solution_, A> leftParent,
BavetJoinBridgeUniConstraintStream<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(NodeBuildHelper<Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<BiTuple<A, B>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractJoinNode<UniTuple<A>, B, BiTuple<A, B>, BiTupleImpl<A, B>> node = indexerFactory.hasJoiners()
? new IndexedJoinBiNode<>(
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
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,
indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: 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, 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
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetJoinBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetJoinBridgeBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private final boolean isLeftBridge;
private BavetJoinConstraintStream<Solution_> joinStream;
public BavetJoinBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, boolean isLeftBridge) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.isLeftBridge = isLeftBridge;
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
public void setJoinStream(BavetJoinConstraintStream<Solution_> joinStream) {
this.joinStream = joinStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
public BavetAbstractBiConstraintStream<Solution_, A, B> getParent() {
return parent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetJoinTriConstraintStream, etc build everything.
}
@Override
public String toString() {
return "JoinBridge()";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetMapBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Set;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetMapUniConstraintStream;
import ai.timefold.solver.core.api.score.Score;
public final class BavetMapBridgeBiConstraintStream<Solution_, A, B, NewA>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private final BiFunction<A, B, NewA> mappingFunction;
private BavetMapUniConstraintStream<Solution_, NewA> mapStream;
public BavetMapBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent, BiFunction<A, B, NewA> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setMapStream(BavetMapUniConstraintStream<Solution_, NewA> mapStream) {
this.mapStream = mapStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has a non-empty childStreamList (" + childStreamList + ") but it's a flattenLast bridge.");
}
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(mapStream);
AbstractMapNode<BiTuple<A, B>, NewA> node = new MapBiNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(mapStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetQuadGroupBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetGroupQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetQuadGroupBridgeBiConstraintStream<Solution_, A, B, NewA, NewB, NewC, NewD>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private BavetGroupQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> groupStream;
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
public BavetQuadGroupBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetScoringBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.common.inliner.JustificationsSupplier.of;
import java.math.BigDecimal;
import java.util.Set;
import java.util.function.BiFunction;
import java.util.function.ToIntBiFunction;
import java.util.function.ToLongBiFunction;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraint;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.common.inliner.JustificationsSupplier;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.constraint.streams.common.inliner.WeightedScoreImpacter;
import ai.timefold.solver.core.api.score.Score;
public final class BavetScoringBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements BavetScoringConstraintStream<Solution_> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private final boolean noMatchWeigher;
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, false, 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, false, 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, false, 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,
boolean noMatchWeigher,
ToIntBiFunction<A, B> intMatchWeigher, ToLongBiFunction<A, B> longMatchWeigher,
BiFunction<A, B, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.noMatchWeigher = noMatchWeigher;
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has an non-empty childStreamList (" + childStreamList + ") but it's an endpoint.");
}
Score_ constraintWeight = buildHelper.getConstraintWeight(constraint);
WeightedScoreImpacter<Score_, ?> weightedScoreImpacter =
buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint, constraintWeight);
boolean constraintMatchEnabled = buildHelper.getScoreInliner().isConstraintMatchEnabled();
BiFunction<A, B, UndoScoreImpacter> scoreImpacter;
if (intMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (longMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (bigDecimalMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (noMatchWeigher) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b) -> {
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b);
return weightedScoreImpacter.impactScore(1, justificationsSupplier);
};
} else {
scoreImpacter = (a, b) -> weightedScoreImpacter.impactScore(1, null);
}
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
BiScorer<A, B> scorer = new BiScorer<>(constraint.getConstraintPackage(), constraint.getConstraintName(),
constraintWeight, scoreImpacter, buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintName() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetTriGroupBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetGroupTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetTriGroupBridgeBiConstraintStream<Solution_, A, B, NewA, NewB, NewC>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream;
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
public BavetTriGroupBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BavetUniGroupBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetGroupUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetUniGroupBridgeBiConstraintStream<Solution_, A, B, NewA>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
private final BavetAbstractBiConstraintStream<Solution_, A, B> parent;
private BavetGroupUniConstraintStream<Solution_, NewA> groupStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent,
GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupUniConstraintStream<Solution_, NewA> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BiScorer.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractScorer;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.api.score.Score;
final class BiScorer<A, B> extends AbstractScorer<BiTuple<A, B>> {
private final BiFunction<A, B, UndoScoreImpacter> scoreImpacter;
public BiScorer(String constraintPackage, String constraintName, Score<?> constraintWeight,
BiFunction<A, B, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(constraintPackage, constraintName, constraintWeight, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(BiTuple<A, B> tuple) {
try {
return scoreImpacter.apply(tuple.getFactA(), tuple.getFactB());
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BiTuple.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import ai.timefold.solver.constraint.streams.bavet.common.Tuple;
public interface BiTuple<A, B> extends Tuple {
A getFactA();
B getFactB();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/BiTupleImpl.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractTuple;
public final class BiTupleImpl<A, B> extends AbstractTuple implements BiTuple<A, B> {
// Only a tuple's origin node may modify a fact.
public A factA;
public B factB;
public BiTupleImpl(A factA, B factB, int storeSize) {
super(storeSize);
this.factA = factA;
this.factB = factB;
}
@Override
public A getFactA() {
return factA;
}
@Override
public B getFactB() {
return factB;
}
@Override
public String toString() {
return "{" + factA + ", " + factB + "}";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/ConditionalBiTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiPredicate;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConditionalTupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
final class ConditionalBiTupleLifecycle<A, B> extends AbstractConditionalTupleLifecycle<BiTuple<A, B>> {
private final BiPredicate<A, B> predicate;
public ConditionalBiTupleLifecycle(BiPredicate<A, B> predicate, TupleLifecycle<BiTuple<A, B>> tupleLifecycle) {
super(tupleLifecycle);
this.predicate = predicate;
}
@Override
protected boolean test(BiTuple<A, B> tuple) {
return predicate.test(tuple.getFactA(), tuple.getFactB());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/FlattenLastBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
final class FlattenLastBiNode<A, B, NewB> extends AbstractFlattenLastNode<BiTuple<A, B>, BiTuple<A, NewB>, B, NewB> {
private final int outputStoreSize;
FlattenLastBiNode(int flattenLastStoreIndex, Function<B, Iterable<NewB>> mappingFunction,
TupleLifecycle<BiTuple<A, NewB>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected BiTuple<A, NewB> createTuple(BiTuple<A, B> originalTuple, NewB newB) {
return new BiTupleImpl<>(originalTuple.getFactA(), newB, outputStoreSize);
}
@Override
protected B getEffectiveFactIn(BiTuple<A, B> tuple) {
return tuple.getFactB();
}
@Override
protected NewB getEffectiveFactOut(BiTuple<A, NewB> outTuple) {
return outTuple.getFactB();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group0Mapping1CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTupleImpl;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group0Mapping1CollectorBiNode<OldA, OldB, A, ResultContainer_>
extends AbstractGroupBiNode<OldA, OldB, UniTuple<A>, UniTupleImpl<A>, Void, ResultContainer_, A> {
private final int outputStoreSize;
public Group0Mapping1CollectorBiNode(int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainer_, A> collector,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, null, collector, nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected UniTupleImpl<A> createOutTuple(Void groupKey) {
return new UniTupleImpl<>(null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTupleImpl<A> outTuple, A a) {
outTuple.factA = a;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group0Mapping2CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group0Mapping2CollectorBiNode<OldA, OldB, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupBiNode<OldA, OldB, BiTuple<A, B>, BiTupleImpl<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorBiNode(int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainerA_, A> collectorA,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, null, mergeCollectors(collectorA, collectorB), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, A, B, ResultContainerA_, ResultContainerB_>
BiConstraintCollector<OldA, OldB, Object, Pair<A, B>> mergeCollectors(
BiConstraintCollector<OldA, OldB, ResultContainerA_, A> collectorA,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB) {
return (BiConstraintCollector<OldA, OldB, Object, Pair<A, B>>) ConstraintCollectors.compose(collectorA, collectorB,
Pair::of);
}
@Override
protected BiTupleImpl<A, B> createOutTuple(Void groupKey) {
return new BiTupleImpl<>(null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, Pair<A, B> result) {
outTuple.factA = result.getKey();
outTuple.factB = result.getValue();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group0Mapping3CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group0Mapping3CollectorBiNode<OldA, OldB, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends AbstractGroupBiNode<OldA, OldB, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorBiNode(int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainerA_, A> collectorA,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB,
BiConstraintCollector<OldA, OldB, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, null, mergeCollectors(collectorA, collectorB, collectorC),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
BiConstraintCollector<OldA, OldB, Object, Triple<A, B, C>> mergeCollectors(
BiConstraintCollector<OldA, OldB, ResultContainerA_, A> collectorA,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB,
BiConstraintCollector<OldA, OldB, ResultContainerC_, C> collectorC) {
return (BiConstraintCollector<OldA, OldB, Object, Triple<A, B, C>>) ConstraintCollectors.compose(collectorA, collectorB,
collectorC, Triple::of);
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Void groupKey) {
return new TriTupleImpl<>(null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Triple<A, B, C> result) {
outTuple.factA = result.getA();
outTuple.factB = result.getB();
outTuple.factC = result.getC();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group0Mapping4CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group0Mapping4CollectorBiNode<OldA, OldB, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupBiNode<OldA, OldB, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorBiNode(int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainerA_, A> collectorA,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB,
BiConstraintCollector<OldA, OldB, ResultContainerC_, C> collectorC,
BiConstraintCollector<OldA, OldB, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, null, mergeCollectors(collectorA, collectorB, collectorC, collectorD),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <OldA, OldB, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
BiConstraintCollector<OldA, OldB, Object, Quadruple<A, B, C, D>> mergeCollectors(
BiConstraintCollector<OldA, OldB, ResultContainerA_, A> collectorA,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB,
BiConstraintCollector<OldA, OldB, ResultContainerC_, C> collectorC,
BiConstraintCollector<OldA, OldB, ResultContainerD_, D> collectorD) {
return (BiConstraintCollector<OldA, OldB, Object, Quadruple<A, B, C, D>>) ConstraintCollectors.compose(collectorA,
collectorB, collectorC, collectorD, Quadruple::of);
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Void groupKey) {
return new QuadTupleImpl<>(null, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Quadruple<A, B, C, D> result) {
outTuple.factA = result.getA();
outTuple.factB = result.getB();
outTuple.factC = result.getC();
outTuple.factD = result.getD();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group1Mapping0CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTupleImpl;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping0CollectorBiNode<OldA, OldB, A>
extends AbstractGroupBiNode<OldA, OldB, UniTuple<A>, UniTupleImpl<A>, A, Void, Void> {
private final int outputStoreSize;
public Group1Mapping0CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMapping, int groupStoreIndex,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, OldA, OldB> A createGroupKey(BiFunction<OldA, OldB, A> groupKeyMapping, BiTuple<OldA, OldB> tuple) {
return groupKeyMapping.apply(tuple.getFactA(), tuple.getFactB());
}
@Override
protected UniTupleImpl<A> createOutTuple(A a) {
return new UniTupleImpl<>(a, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTupleImpl<A> aUniTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group1Mapping1CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group1Mapping0CollectorBiNode.createGroupKey;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping1CollectorBiNode<OldA, OldB, A, B, ResultContainer_>
extends AbstractGroupBiNode<OldA, OldB, BiTuple<A, B>, BiTupleImpl<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMapping, int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainer_, B> collector,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected BiTupleImpl<A, B> createOutTuple(A a) {
return new BiTupleImpl<>(a, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, B b) {
outTuple.factB = b;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group1Mapping2CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group1Mapping0CollectorBiNode.createGroupKey;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group1Mapping2CollectorBiNode<OldA, OldB, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupBiNode<OldA, OldB, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, A, Object, Pair<B, C>> {
private final int outputStoreSize;
public Group1Mapping2CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMapping, int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB,
BiConstraintCollector<OldA, OldB, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorBiNode.mergeCollectors(collectorB, collectorC), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(A a) {
return new TriTupleImpl<>(a, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Pair<B, C> result) {
outTuple.factB = result.getKey();
outTuple.factC = result.getValue();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group1Mapping3CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group0Mapping3CollectorBiNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group1Mapping0CollectorBiNode.createGroupKey;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group1Mapping3CollectorBiNode<OldA, OldB, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends AbstractGroupBiNode<OldA, OldB, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMapping, int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainerB_, B> collectorB,
BiConstraintCollector<OldA, OldB, ResultContainerC_, C> collectorC,
BiConstraintCollector<OldA, OldB, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple),
mergeCollectors(collectorB, collectorC, collectorD), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(A a) {
return new QuadTupleImpl<>(a, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Triple<B, C, D> result) {
outTuple.factB = result.getA();
outTuple.factC = result.getB();
outTuple.factD = result.getC();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group2Mapping0CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping0CollectorBiNode<OldA, OldB, A, B>
extends AbstractGroupBiNode<OldA, OldB, BiTuple<A, B>, BiTupleImpl<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMappingA, BiFunction<OldA, OldB, B> groupKeyMappingB,
int groupStoreIndex, TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, OldA, OldB> Pair<A, B> createGroupKey(BiFunction<OldA, OldB, A> groupKeyMappingA,
BiFunction<OldA, OldB, B> groupKeyMappingB, BiTuple<OldA, OldB> tuple) {
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
A a = groupKeyMappingA.apply(oldA, oldB);
B b = groupKeyMappingB.apply(oldA, oldB);
return Pair.of(a, b);
}
@Override
protected BiTupleImpl<A, B> createOutTuple(Pair<A, B> groupKey) {
return new BiTupleImpl<>(groupKey.getKey(), groupKey.getValue(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group2Mapping1CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group2Mapping0CollectorBiNode.createGroupKey;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping1CollectorBiNode<OldA, OldB, A, B, C, ResultContainer_>
extends AbstractGroupBiNode<OldA, OldB, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Pair<A, B>, ResultContainer_, C> {
private final int outputStoreSize;
public Group2Mapping1CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMappingA, BiFunction<OldA, OldB, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex, BiConstraintCollector<OldA, OldB, ResultContainer_, C> collector,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Pair<A, B> groupKey) {
return new TriTupleImpl<>(groupKey.getKey(), groupKey.getValue(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, C c) {
outTuple.factC = c;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group2Mapping2CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group0Mapping2CollectorBiNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group2Mapping0CollectorBiNode.createGroupKey;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping2CollectorBiNode<OldA, OldB, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupBiNode<OldA, OldB, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMappingA, BiFunction<OldA, OldB, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
BiConstraintCollector<OldA, OldB, ResultContainerC_, C> collectorC,
BiConstraintCollector<OldA, OldB, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple),
mergeCollectors(collectorC, collectorD), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Pair<A, B> groupKey) {
return new QuadTupleImpl<>(groupKey.getKey(), groupKey.getValue(), null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Pair<C, D> result) {
outTuple.factC = result.getKey();
outTuple.factD = result.getValue();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group3Mapping0CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping0CollectorBiNode<OldA, OldB, A, B, C>
extends AbstractGroupBiNode<OldA, OldB, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMappingA, BiFunction<OldA, OldB, B> groupKeyMappingB,
BiFunction<OldA, OldB, C> groupKeyMappingC, int groupStoreIndex,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, C, OldA, OldB> Triple<A, B, C> createGroupKey(BiFunction<OldA, OldB, A> groupKeyMappingA,
BiFunction<OldA, OldB, B> groupKeyMappingB, BiFunction<OldA, OldB, C> groupKeyMappingC,
BiTuple<OldA, OldB> tuple) {
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
A a = groupKeyMappingA.apply(oldA, oldB);
B b = groupKeyMappingB.apply(oldA, oldB);
C c = groupKeyMappingC.apply(oldA, oldB);
return Triple.of(a, b, c);
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group3Mapping1CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import static ai.timefold.solver.constraint.streams.bavet.bi.Group3Mapping0CollectorBiNode.createGroupKey;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping1CollectorBiNode<OldA, OldB, A, B, C, D, ResultContainer_>
extends
AbstractGroupBiNode<OldA, OldB, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Triple<A, B, C>, ResultContainer_, D> {
private final int outputStoreSize;
public Group3Mapping1CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMappingA,
BiFunction<OldA, OldB, B> groupKeyMappingB, BiFunction<OldA, OldB, C> groupKeyMappingC,
int groupStoreIndex, int undoStoreIndex, BiConstraintCollector<OldA, OldB, ResultContainer_, D> collector,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Triple<A, B, C> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, D d) {
outTuple.factD = d;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/Group4Mapping0CollectorBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group4Mapping0CollectorBiNode<OldA, OldB, A, B, C, D>
extends
AbstractGroupBiNode<OldA, OldB, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorBiNode(BiFunction<OldA, OldB, A> groupKeyMappingA, BiFunction<OldA, OldB, B> groupKeyMappingB,
BiFunction<OldA, OldB, C> groupKeyMappingC, BiFunction<OldA, OldB, D> groupKeyMappingD, int groupStoreIndex,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, groupKeyMappingD, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <A, B, C, D, OldA, OldB> Quadruple<A, B, C, D> createGroupKey(
BiFunction<OldA, OldB, A> groupKeyMappingA, BiFunction<OldA, OldB, B> groupKeyMappingB,
BiFunction<OldA, OldB, C> groupKeyMappingC, BiFunction<OldA, OldB, D> groupKeyMappingD,
BiTuple<OldA, OldB> tuple) {
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
A a = groupKeyMappingA.apply(oldA, oldB);
B b = groupKeyMappingB.apply(oldA, oldB);
C c = groupKeyMappingC.apply(oldA, oldB);
D d = groupKeyMappingD.apply(oldA, oldB);
return Quadruple.of(a, b, c, d);
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), groupKey.getD(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/IndexedIfExistsBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractIndexedIfExistsNode;
import ai.timefold.solver.constraint.streams.bavet.common.ExistsCounter;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.TriPredicate;
final class IndexedIfExistsBiNode<A, B, C> extends AbstractIndexedIfExistsNode<BiTuple<A, B>, C> {
private final BiFunction<A, B, IndexProperties> mappingAB;
private final TriPredicate<A, B, C> filtering;
public IndexedIfExistsBiNode(boolean shouldExist,
BiFunction<A, B, IndexProperties> mappingAB, Function<C, IndexProperties> mappingC,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<BiTuple<A, B>>> indexerAB, Indexer<UniTuple<C>> indexerC) {
this(shouldExist, mappingAB, mappingC,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, -1,
inputStoreIndexRightProperties, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, indexerAB, indexerC,
null);
}
public IndexedIfExistsBiNode(boolean shouldExist,
BiFunction<A, B, IndexProperties> mappingAB, Function<C, IndexProperties> mappingC,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<BiTuple<A, B>>> indexerAB, Indexer<UniTuple<C>> indexerC,
TriPredicate<A, B, C> filtering) {
super(shouldExist, mappingC,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightProperties, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, indexerAB, indexerC,
filtering != null);
this.mappingAB = mappingAB;
this.filtering = filtering;
}
@Override
protected IndexProperties createIndexProperties(BiTuple<A, B> leftTuple) {
return mappingAB.apply(leftTuple.getFactA(), leftTuple.getFactB());
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/IndexedJoinBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiPredicate;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractIndexedJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
final class IndexedJoinBiNode<A, B> extends AbstractIndexedJoinNode<UniTuple<A>, B, BiTuple<A, B>, BiTupleImpl<A, B>> {
private final Function<A, IndexProperties> mappingA;
private final BiPredicate<A, B> filtering;
private final int outputStoreSize;
public IndexedJoinBiNode(Function<A, IndexProperties> mappingA, Function<B, IndexProperties> mappingB,
int inputStoreIndexA, int inputStoreIndexEntryA, int inputStoreIndexOutTupleListA,
int inputStoreIndexB, int inputStoreIndexEntryB, int inputStoreIndexOutTupleListB,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, BiPredicate<A, B> filtering,
int outputStoreSize,
int outputStoreIndexOutEntryA, int outputStoreIndexOutEntryB,
Indexer<UniTuple<A>> indexerA,
Indexer<UniTuple<B>> indexerB) {
super(mappingB,
inputStoreIndexA, inputStoreIndexEntryA, inputStoreIndexOutTupleListA,
inputStoreIndexB, inputStoreIndexEntryB, inputStoreIndexOutTupleListB,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexOutEntryA, outputStoreIndexOutEntryB,
indexerA, indexerB);
this.mappingA = mappingA;
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected IndexProperties createIndexPropertiesLeft(UniTuple<A> leftTuple) {
return mappingA.apply(leftTuple.getFactA());
}
@Override
protected BiTupleImpl<A, B> createOutTuple(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return new BiTupleImpl<>(leftTuple.getFactA(), rightTuple.getFactA(), outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(BiTupleImpl<A, B> outTuple, UniTuple<A> leftTuple) {
outTuple.factA = leftTuple.getFactA();
}
@Override
protected void setOutTupleRightFact(BiTupleImpl<A, B> outTuple, UniTuple<B> rightTuple) {
outTuple.factB = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return filtering.test(leftTuple.getFactA(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/MapBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
final class MapBiNode<A, B, NewA> extends AbstractMapNode<BiTuple<A, B>, NewA> {
private final BiFunction<A, B, NewA> mappingFunction;
MapBiNode(int mapStoreIndex, BiFunction<A, B, NewA> mappingFunction, TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle,
int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
protected NewA map(BiTuple<A, B> tuple) {
return mappingFunction.apply(tuple.getFactA(), tuple.getFactB());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/UnindexedIfExistsBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedIfExistsNode;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.TriPredicate;
final class UnindexedIfExistsBiNode<A, B, C> extends AbstractUnindexedIfExistsNode<BiTuple<A, B>, C> {
private final TriPredicate<A, B, C> filtering;
public UnindexedIfExistsBiNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightEntry,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle) {
this(shouldExist,
inputStoreIndexLeftCounterEntry, -1,
inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public UnindexedIfExistsBiNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle,
TriPredicate<A, B, C> filtering) {
super(shouldExist,
inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/bi/UnindexedJoinBiNode.java | package ai.timefold.solver.constraint.streams.bavet.bi;
import java.util.function.BiPredicate;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
final class UnindexedJoinBiNode<A, B>
extends AbstractUnindexedJoinNode<UniTuple<A>, B, BiTuple<A, B>, BiTupleImpl<A, B>> {
private final BiPredicate<A, B> filtering;
private final int outputStoreSize;
public UnindexedJoinBiNode(
int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, BiPredicate<A, B> filtering,
int outputStoreSize,
int outputStoreIndexLeftOutEntry, int outputStoreIndexRightOutEntry) {
super(inputStoreIndexLeftEntry, inputStoreIndexLeftOutTupleList,
inputStoreIndexRightEntry, inputStoreIndexRightOutTupleList,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexLeftOutEntry, outputStoreIndexRightOutEntry);
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected BiTupleImpl<A, B> createOutTuple(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return new BiTupleImpl<>(leftTuple.getFactA(), rightTuple.getFactA(), outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(BiTupleImpl<A, B> outTuple, UniTuple<A> leftTuple) {
outTuple.factA = leftTuple.getFactA();
}
@Override
protected void setOutTupleRightFact(BiTupleImpl<A, B> outTuple, UniTuple<B> rightTuple) {
outTuple.factB = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return filtering.test(leftTuple.getFactA(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractConditionalTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.Objects;
public abstract class AbstractConditionalTupleLifecycle<Tuple_ extends Tuple>
implements TupleLifecycle<Tuple_> {
private final TupleLifecycle<Tuple_> tupleLifecycle;
protected AbstractConditionalTupleLifecycle(TupleLifecycle<Tuple_> tupleLifecycle) {
this.tupleLifecycle = Objects.requireNonNull(tupleLifecycle);
}
@Override
public final void insert(Tuple_ tuple) {
if (test(tuple)) {
tupleLifecycle.insert(tuple);
}
}
@Override
public final void update(Tuple_ tuple) {
if (test(tuple)) {
tupleLifecycle.update(tuple);
} else {
tupleLifecycle.retract(tuple);
}
}
@Override
public final void retract(Tuple_ tuple) {
tupleLifecycle.retract(tuple);
}
abstract protected boolean test(Tuple_ tuple);
@Override
public String toString() {
return "Conditional " + tupleLifecycle;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractFlattenLastNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.ArrayDeque;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.Queue;
import java.util.function.Function;
public abstract class AbstractFlattenLastNode<InTuple_ extends Tuple, OutTuple_ extends Tuple, EffectiveItem_, FlattenedItem_>
extends AbstractNode
implements TupleLifecycle<InTuple_> {
private final int flattenLastStoreIndex;
private final Function<EffectiveItem_, Iterable<FlattenedItem_>> mappingFunction;
/**
* Calls for example {@link AbstractScorer#insert(Tuple)}, and/or ...
*/
private final TupleLifecycle<OutTuple_> nextNodesTupleLifecycle;
private final Queue<OutTuple_> dirtyTupleQueue = new ArrayDeque<>(1000);
protected AbstractFlattenLastNode(int flattenLastStoreIndex,
Function<EffectiveItem_, Iterable<FlattenedItem_>> mappingFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle) {
this.flattenLastStoreIndex = flattenLastStoreIndex;
this.mappingFunction = Objects.requireNonNull(mappingFunction);
this.nextNodesTupleLifecycle = Objects.requireNonNull(nextNodesTupleLifecycle);
}
@Override
public void insert(InTuple_ tuple) {
if (tuple.getStore(flattenLastStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
List<OutTuple_> outTupleList = new ArrayList<>();
for (FlattenedItem_ item : mappingFunction.apply(getEffectiveFactIn(tuple))) {
addTuple(tuple, item, outTupleList);
}
if (!outTupleList.isEmpty()) {
tuple.setStore(flattenLastStoreIndex, outTupleList);
}
}
private void addTuple(InTuple_ originalTuple, FlattenedItem_ item, List<OutTuple_> outTupleList) {
OutTuple_ tuple = createTuple(originalTuple, item);
outTupleList.add(tuple);
dirtyTupleQueue.add(tuple);
}
protected abstract OutTuple_ createTuple(InTuple_ originalTuple, FlattenedItem_ item);
@Override
public void update(InTuple_ tuple) {
List<OutTuple_> outTupleList = tuple.getStore(flattenLastStoreIndex);
if (outTupleList == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s).
insert(tuple);
return;
}
Iterator<FlattenedItem_> iterator = mappingFunction.apply(getEffectiveFactIn(tuple)).iterator();
if (!iterator.hasNext()) { // No need for incremental logic as everything will be removed.
retract(tuple);
return;
}
// Convert Iterable into something we can query.
List<FlattenedItem_> newFlattenedItemList = new ArrayList<>();
iterator.forEachRemaining(newFlattenedItemList::add);
// Remove all facts from the input that are already contained.
Iterator<OutTuple_> outTupleIterator = outTupleList.listIterator();
while (outTupleIterator.hasNext()) {
OutTuple_ outTuple = outTupleIterator.next();
FlattenedItem_ existingFlattenedItem = getEffectiveFactOut(outTuple);
// A fact can be present more than once and every iteration should only remove one instance.
boolean existsAlsoInNew = false;
Iterator<FlattenedItem_> newFlattenedItemIterator = newFlattenedItemList.listIterator();
while (newFlattenedItemIterator.hasNext()) {
FlattenedItem_ newFlattenedItem = newFlattenedItemIterator.next();
// We check for identity, not equality, to not introduce dependency on user equals().
if (newFlattenedItem == existingFlattenedItem) {
// Remove item from the list, as it means its tuple need not be added later.
newFlattenedItemIterator.remove();
existsAlsoInNew = true;
break;
}
}
if (!existsAlsoInNew) {
outTupleIterator.remove();
removeTuple(outTuple);
} else {
outTuple.setState(BavetTupleState.UPDATING);
dirtyTupleQueue.add(outTuple);
}
}
// Whatever is left in the input needs to be added.
for (FlattenedItem_ newFlattenedItem : newFlattenedItemList) {
addTuple(tuple, newFlattenedItem, outTupleList);
}
}
protected abstract EffectiveItem_ getEffectiveFactIn(InTuple_ tuple);
protected abstract FlattenedItem_ getEffectiveFactOut(OutTuple_ outTuple);
@Override
public void retract(InTuple_ tuple) {
List<OutTuple_> outTupleList = tuple.removeStore(flattenLastStoreIndex);
if (outTupleList == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
for (OutTuple_ item : outTupleList) {
removeTuple(item);
}
}
private void removeTuple(OutTuple_ outTuple) {
switch (outTuple.getState()) {
case CREATING:
outTuple.setState(BavetTupleState.ABORTING);
break;
case UPDATING:
case OK:
outTuple.setState(BavetTupleState.DYING);
break;
default:
throw new IllegalStateException("Impossible state: The tuple (" + outTuple +
") is in an unexpected state (" + outTuple.getState() + ").");
}
dirtyTupleQueue.add(outTuple);
}
@Override
public void calculateScore() {
for (OutTuple_ outTuple : dirtyTupleQueue) {
switch (outTuple.getState()) {
case CREATING:
nextNodesTupleLifecycle.insert(outTuple);
outTuple.setState(BavetTupleState.OK);
break;
case UPDATING:
nextNodesTupleLifecycle.update(outTuple);
outTuple.setState(BavetTupleState.OK);
break;
case DYING:
nextNodesTupleLifecycle.retract(outTuple);
outTuple.setState(BavetTupleState.DEAD);
break;
case ABORTING:
outTuple.setState(BavetTupleState.DEAD);
break;
default:
throw new IllegalStateException("Impossible state: The tuple (" + outTuple + ") in node (" +
this + ") is in an unexpected state (" + outTuple.getState() + ").");
}
}
dirtyTupleQueue.clear();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractGroup.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.Objects;
abstract class AbstractGroup<OutTuple_ extends Tuple, ResultContainer_> {
public final Object groupKey;
public final OutTuple_ outTuple;
public int parentCount = 1;
public AbstractGroup(Object groupKey, OutTuple_ outTuple) {
this.groupKey = groupKey;
this.outTuple = outTuple;
}
public final Object getGroupKey() {
return groupKey;
}
public abstract ResultContainer_ getResultContainer();
public final OutTuple_ getOutTuple() {
return outTuple;
}
@Override
public final String toString() {
return Objects.toString(groupKey);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractGroupNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.ArrayDeque;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.Queue;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
public abstract class AbstractGroupNode<InTuple_ extends Tuple, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_, GroupKey_, ResultContainer_, Result_>
extends AbstractNode
implements TupleLifecycle<InTuple_> {
private final int groupStoreIndex;
/**
* Unused when {@link #hasCollector} is false.
*/
private final int undoStoreIndex;
/**
* Unused when {@link #hasMultipleGroups} is false.
*/
private final Function<InTuple_, GroupKey_> groupKeyFunction;
/**
* Unused when {@link #hasCollector} is false.
*/
private final Supplier<ResultContainer_> supplier;
/**
* Unused when {@link #hasCollector} is false.
*/
private final Function<ResultContainer_, Result_> finisher;
/**
* Some code paths may decide to not supply a grouping function.
* In that case, every tuple accumulates into {@link #singletonGroup} and not to {@link #groupMap}.
*/
private final boolean hasMultipleGroups;
/**
* Some code paths may decide to not supply a collector.
* In that case, we skip the code path that would attempt to use it.
*/
private final boolean hasCollector;
/**
* Calls for example {@link AbstractScorer#insert(Tuple)}, and/or ...
*/
private final TupleLifecycle<OutTuple_> nextNodesTupleLifecycle;
/**
* Used when {@link #hasMultipleGroups} is true, otherwise {@link #singletonGroup} is used.
*/
private final Map<Object, AbstractGroup<MutableOutTuple_, ResultContainer_>> groupMap;
/**
* Used when {@link #hasMultipleGroups} is false, otherwise {@link #groupMap} is used.
*
* @implNote The field is lazy initialized in order to maintain the same semantics as with the groupMap above.
* When all tuples are removed, the field will be set to null, as if the group never existed.
*/
private AbstractGroup<MutableOutTuple_, ResultContainer_> singletonGroup;
private final Queue<AbstractGroup<MutableOutTuple_, ResultContainer_>> dirtyGroupQueue;
private final boolean useAssertingGroupKey;
protected AbstractGroupNode(int groupStoreIndex, int undoStoreIndex, Function<InTuple_, GroupKey_> groupKeyFunction,
Supplier<ResultContainer_> supplier, Function<ResultContainer_, Result_> finisher,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
this.groupStoreIndex = groupStoreIndex;
this.undoStoreIndex = undoStoreIndex;
this.groupKeyFunction = groupKeyFunction;
this.supplier = supplier;
this.finisher = finisher;
this.hasMultipleGroups = groupKeyFunction != null;
this.hasCollector = supplier != null;
this.nextNodesTupleLifecycle = nextNodesTupleLifecycle;
/*
* Not using the default sizing to 1000.
* The number of groups can be very small, and that situation is not unlikely.
* Therefore, the size of these collections is kept default.
*/
this.groupMap = hasMultipleGroups ? new HashMap<>() : null;
this.dirtyGroupQueue = new ArrayDeque<>();
this.useAssertingGroupKey = environmentMode.isAsserted();
}
protected AbstractGroupNode(int groupStoreIndex, Function<InTuple_, GroupKey_> groupKeyFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
this(groupStoreIndex, -1, groupKeyFunction, null, null, nextNodesTupleLifecycle, environmentMode);
}
@Override
public void insert(InTuple_ tuple) {
if (tuple.getStore(groupStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
GroupKey_ userSuppliedKey = hasMultipleGroups ? groupKeyFunction.apply(tuple) : null;
createTuple(tuple, userSuppliedKey);
}
private void createTuple(InTuple_ tuple, GroupKey_ userSuppliedKey) {
AbstractGroup<MutableOutTuple_, ResultContainer_> newGroup = getOrCreateGroup(userSuppliedKey);
OutTuple_ outTuple = accumulate(tuple, newGroup);
switch (outTuple.getState()) {
case CREATING:
case UPDATING:
break;
case OK:
outTuple.setState(BavetTupleState.UPDATING);
dirtyGroupQueue.add(newGroup);
break;
case DYING:
outTuple.setState(BavetTupleState.UPDATING);
break;
case ABORTING:
outTuple.setState(BavetTupleState.CREATING);
break;
case DEAD:
default:
throw new IllegalStateException("Impossible state: The group (" + newGroup + ") in node (" +
this + ") is in an unexpected state (" + outTuple.getState() + ").");
}
}
private OutTuple_ accumulate(InTuple_ tuple, AbstractGroup<MutableOutTuple_, ResultContainer_> group) {
if (hasCollector) {
Runnable undoAccumulator = accumulate(group.getResultContainer(), tuple);
tuple.setStore(undoStoreIndex, undoAccumulator);
}
tuple.setStore(groupStoreIndex, group);
return group.outTuple;
}
private AbstractGroup<MutableOutTuple_, ResultContainer_> getOrCreateGroup(GroupKey_ userSuppliedKey) {
Object groupMapKey = useAssertingGroupKey ? new AssertingGroupKey(userSuppliedKey) : userSuppliedKey;
if (hasMultipleGroups) {
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
AbstractGroup<MutableOutTuple_, ResultContainer_> group = groupMap.get(groupMapKey);
if (group == null) {
group = createGroup(groupMapKey);
groupMap.put(groupMapKey, group);
} else {
group.parentCount++;
}
return group;
} else {
if (singletonGroup == null) {
singletonGroup = createGroup(groupMapKey);
} else {
singletonGroup.parentCount++;
}
return singletonGroup;
}
}
private AbstractGroup<MutableOutTuple_, ResultContainer_> createGroup(Object groupMapKey) {
GroupKey_ userSuppliedKey = extractUserSuppliedKey(groupMapKey);
MutableOutTuple_ outTuple = createOutTuple(userSuppliedKey);
AbstractGroup<MutableOutTuple_, ResultContainer_> group =
hasCollector ? new GroupWithAccumulate<>(groupMapKey, supplier.get(), outTuple)
: new GroupWithoutAccumulate<>(groupMapKey, outTuple);
// Don't add it if (state == CREATING), but (newGroup != null), which is a 2nd insert of the same newGroupKey.
dirtyGroupQueue.add(group);
return group;
}
private GroupKey_ extractUserSuppliedKey(Object groupMapKey) {
return useAssertingGroupKey ? ((AssertingGroupKey) groupMapKey).getKey() : (GroupKey_) groupMapKey;
}
@Override
public void update(InTuple_ tuple) {
AbstractGroup<MutableOutTuple_, ResultContainer_> oldGroup = tuple.getStore(groupStoreIndex);
if (oldGroup == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insert(tuple);
return;
}
if (hasCollector) {
Runnable undoAccumulator = tuple.getStore(undoStoreIndex);
undoAccumulator.run();
}
GroupKey_ oldUserSuppliedGroupKey = extractUserSuppliedKey(oldGroup.groupKey);
GroupKey_ newUserSuppliedGroupKey = hasMultipleGroups ? groupKeyFunction.apply(tuple) : null;
if (Objects.equals(newUserSuppliedGroupKey, oldUserSuppliedGroupKey)) {
// No need to change parentCount because it is the same group
OutTuple_ outTuple = accumulate(tuple, oldGroup);
switch (outTuple.getState()) {
case CREATING:
case UPDATING:
break;
case OK:
outTuple.setState(BavetTupleState.UPDATING);
dirtyGroupQueue.add(oldGroup);
break;
case DYING:
case ABORTING:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The group (" + oldGroup + ") in node (" +
this + ") is in an unexpected state (" + outTuple.getState() + ").");
}
} else {
killTuple(oldGroup);
createTuple(tuple, newUserSuppliedGroupKey);
}
}
private void killTuple(AbstractGroup<MutableOutTuple_, ResultContainer_> group) {
int newParentCount = --group.parentCount;
boolean killGroup = (newParentCount == 0);
if (killGroup) {
Object groupKey = group.groupKey;
AbstractGroup<MutableOutTuple_, ResultContainer_> old = removeGroup(groupKey);
if (old == null) {
throw new IllegalStateException("Impossible state: the group for the groupKey ("
+ groupKey + ") doesn't exist in the groupMap.\n" +
"Maybe groupKey hashcode changed while it shouldn't have?");
}
}
OutTuple_ outTuple = group.outTuple;
switch (outTuple.getState()) {
case CREATING:
if (killGroup) {
outTuple.setState(BavetTupleState.ABORTING);
}
break;
case UPDATING:
if (killGroup) {
outTuple.setState(BavetTupleState.DYING);
}
break;
case OK:
outTuple.setState(killGroup ? BavetTupleState.DYING : BavetTupleState.UPDATING);
dirtyGroupQueue.add(group);
break;
case DYING:
case ABORTING:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The group (" + group + ") in node (" +
this + ") is in an unexpected state (" + outTuple.getState() + ").");
}
}
private AbstractGroup<MutableOutTuple_, ResultContainer_> removeGroup(Object groupKey) {
if (hasMultipleGroups) {
return groupMap.remove(groupKey);
} else {
AbstractGroup<MutableOutTuple_, ResultContainer_> old = singletonGroup;
singletonGroup = null;
return old;
}
}
@Override
public void retract(InTuple_ tuple) {
AbstractGroup<MutableOutTuple_, ResultContainer_> group = tuple.removeStore(groupStoreIndex);
if (group == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
if (hasCollector) {
Runnable undoAccumulator = tuple.removeStore(undoStoreIndex);
undoAccumulator.run();
}
killTuple(group);
}
protected abstract Runnable accumulate(ResultContainer_ resultContainer, InTuple_ tuple);
@Override
public void calculateScore() {
for (AbstractGroup<MutableOutTuple_, ResultContainer_> group : dirtyGroupQueue) {
MutableOutTuple_ outTuple = group.outTuple;
// Delay calculating finisher right until the tuple propagates
switch (outTuple.getState()) {
case CREATING:
if (hasCollector) {
updateOutTupleToFinisher(outTuple, group.getResultContainer());
}
nextNodesTupleLifecycle.insert(outTuple);
outTuple.setState(BavetTupleState.OK);
break;
case UPDATING:
if (hasCollector) {
updateOutTupleToFinisher(outTuple, group.getResultContainer());
}
nextNodesTupleLifecycle.update(outTuple);
outTuple.setState(BavetTupleState.OK);
break;
case DYING:
nextNodesTupleLifecycle.retract(outTuple);
outTuple.setState(BavetTupleState.DEAD);
break;
case ABORTING:
outTuple.setState(BavetTupleState.DEAD);
break;
case OK:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The group (" + group + ") in node (" +
this + ") is in an unexpected state (" + outTuple.getState() + ").");
}
}
dirtyGroupQueue.clear();
}
/**
*
* @param groupKey null if the node only has one group
* @return never null
*/
protected abstract MutableOutTuple_ createOutTuple(GroupKey_ groupKey);
private void updateOutTupleToFinisher(MutableOutTuple_ outTuple, ResultContainer_ resultContainer) {
Result_ result = finisher.apply(resultContainer);
updateOutTupleToResult(outTuple, result);
}
protected abstract void updateOutTupleToResult(MutableOutTuple_ outTuple, Result_ result);
/**
* Group key hashcode must never change once introduced to the group map.
* If it does, unpredictable behavior will occur.
* Since this situation is far too frequent and users run into this,
* we have this helper class that will optionally throw an exception when it detects this.
*/
private final class AssertingGroupKey {
private final GroupKey_ key;
private final int initialHashCode;
public AssertingGroupKey(GroupKey_ key) {
this.key = key;
this.initialHashCode = key == null ? 0 : key.hashCode();
}
public GroupKey_ getKey() {
if (key != null && key.hashCode() != initialHashCode) {
throw new IllegalStateException("hashCode of object (" + key + ") of class (" + key.getClass()
+ ") has changed while it was being used as a group key within groupBy ("
+ AbstractGroupNode.this.getClass() + ").\n"
+ "Group key hashCode must consistently return the same integer, "
+ "as required by the general hashCode contract.");
}
return key;
}
@Override
public boolean equals(Object other) {
if (other == null || getClass() != other.getClass())
return false;
return Objects.equals(getKey(), ((AssertingGroupKey) other).getKey());
}
@Override
public int hashCode() {
GroupKey_ key = getKey();
return key == null ? 0 : key.hashCode();
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractIfExistsNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
import static ai.timefold.solver.constraint.streams.bavet.common.BavetTupleState.DEAD;
import java.util.ArrayDeque;
import java.util.Queue;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleList;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleListEntry;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
/**
* This class has two direct children: {@link AbstractIndexedIfExistsNode} and {@link AbstractUnindexedIfExistsNode}.
* The logic in either is identical, except that the latter removes all indexing work.
* Therefore any time that one of the classes changes,
* the other should be inspected if it could benefit from applying the change there too.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractIfExistsNode<LeftTuple_ extends Tuple, Right_>
extends AbstractNode
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
protected final boolean shouldExist;
protected final int inputStoreIndexLeftTrackerList; // -1 if !isFiltering
protected final int inputStoreIndexRightTrackerList; // -1 if !isFiltering
/**
* Calls for example {@link AbstractScorer#insert(Tuple)}, and/or ...
*/
private final TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle;
protected final boolean isFiltering;
// No outputStoreSize because this node is not a tuple source, even though it has a dirtyCounterQueue.
protected final Queue<ExistsCounter<LeftTuple_>> dirtyCounterQueue;
protected AbstractIfExistsNode(boolean shouldExist,
int inputStoreIndexLeftTrackerList, int inputStoreIndexRightTrackerList,
TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle,
boolean isFiltering) {
this.shouldExist = shouldExist;
this.inputStoreIndexLeftTrackerList = inputStoreIndexLeftTrackerList;
this.inputStoreIndexRightTrackerList = inputStoreIndexRightTrackerList;
this.nextNodesTupleLifecycle = nextNodesTupleLifecycle;
this.isFiltering = isFiltering;
this.dirtyCounterQueue = new ArrayDeque<>(1000);
}
protected abstract boolean testFiltering(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple);
protected void initCounterLeft(ExistsCounter<LeftTuple_> counter) {
if (shouldExist ? counter.countRight > 0 : counter.countRight == 0) {
// Counters start out dead
counter.state = BavetTupleState.CREATING;
dirtyCounterQueue.add(counter);
}
}
protected final void updateUnchangedCounterLeft(ExistsCounter<LeftTuple_> counter) {
switch (counter.state) {
case CREATING:
case UPDATING:
case DYING:
case ABORTING:
case DEAD:
// Counter state does not change because the index properties didn't change
break;
case OK:
// Still needed to propagate the update for downstream filters, matchWeighers, ...
counter.state = BavetTupleState.UPDATING;
dirtyCounterQueue.add(counter);
break;
default:
throw new IllegalStateException("Impossible state: The counter (" + counter.state + ") in node (" +
this + ") is in an unexpected state (" + counter.state + ").");
}
}
protected void updateCounterLeft(ExistsCounter<LeftTuple_> counter) {
if (shouldExist ? counter.countRight > 0 : counter.countRight == 0) {
// Insert or update
switch (counter.state) {
case CREATING:
case UPDATING:
// Don't add the tuple to the dirtyTupleQueue twice
break;
case OK:
counter.state = BavetTupleState.UPDATING;
dirtyCounterQueue.add(counter);
break;
case DYING:
counter.state = BavetTupleState.UPDATING;
break;
case DEAD:
counter.state = BavetTupleState.CREATING;
dirtyCounterQueue.add(counter);
break;
case ABORTING:
counter.state = BavetTupleState.CREATING;
break;
default:
throw new IllegalStateException("Impossible state: the counter (" + counter
+ ") has an impossible insert state (" + counter.state + ").");
}
} else {
// Retract or remain dead
switch (counter.state) {
case CREATING:
// Kill it before it propagates
counter.state = BavetTupleState.ABORTING;
break;
case UPDATING:
// Kill the original propagation
counter.state = BavetTupleState.DYING;
break;
case OK:
counter.state = BavetTupleState.DYING;
dirtyCounterQueue.add(counter);
break;
case DYING:
case DEAD:
case ABORTING:
// Don't add the tuple to the dirtyTupleQueue twice
break;
default:
throw new IllegalStateException("Impossible state: The counter (" + counter
+ ") has an impossible retract state (" + counter.state + ").");
}
}
}
protected void killCounterLeft(ExistsCounter<LeftTuple_> counter) {
if (shouldExist ? counter.countRight > 0 : counter.countRight == 0) {
doRetractCounter(counter);
}
}
protected void incrementCounterRight(ExistsCounter<LeftTuple_> counter) {
if (counter.countRight == 0) {
if (shouldExist) {
doInsertCounter(counter);
} else {
doRetractCounter(counter);
}
} // Else do not even propagate an update
counter.countRight++;
}
protected void decrementCounterRight(ExistsCounter<LeftTuple_> counter) {
counter.countRight--;
if (counter.countRight == 0) {
if (shouldExist) {
doRetractCounter(counter);
} else {
doInsertCounter(counter);
}
} // Else do not even propagate an update
}
protected TupleList<FilteringTracker<LeftTuple_>> updateRightTrackerList(UniTuple<Right_> rightTuple) {
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList = rightTuple.getStore(inputStoreIndexRightTrackerList);
rightTrackerList.forEach(filteringTacker -> {
decrementCounterRight(filteringTacker.counter);
filteringTacker.remove();
});
return rightTrackerList;
}
protected void updateCounterFromLeft(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter,
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList) {
if (testFiltering(leftTuple, rightTuple)) {
counter.countRight++;
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList = rightTuple.getStore(inputStoreIndexRightTrackerList);
new FilteringTracker<>(counter, leftTrackerList, rightTrackerList);
}
}
protected void updateCounterFromRight(UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter,
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList) {
if (testFiltering(counter.leftTuple, rightTuple)) {
incrementCounterRight(counter);
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList =
counter.leftTuple.getStore(inputStoreIndexLeftTrackerList);
new FilteringTracker<>(counter, leftTrackerList, rightTrackerList);
}
}
private void doInsertCounter(ExistsCounter<LeftTuple_> counter) {
switch (counter.state) {
case DYING:
counter.state = BavetTupleState.UPDATING;
break;
case DEAD:
counter.state = BavetTupleState.CREATING;
dirtyCounterQueue.add(counter);
break;
case ABORTING:
counter.state = BavetTupleState.CREATING;
break;
default:
throw new IllegalStateException("Impossible state: the counter (" + counter
+ ") has an impossible insert state (" + counter.state + ").");
}
}
private void doRetractCounter(ExistsCounter<LeftTuple_> counter) {
switch (counter.state) {
case CREATING:
// Kill it before it propagates
counter.state = BavetTupleState.ABORTING;
break;
case UPDATING:
// Kill the original propagation
counter.state = BavetTupleState.DYING;
break;
case OK:
counter.state = BavetTupleState.DYING;
dirtyCounterQueue.add(counter);
break;
default:
throw new IllegalStateException("Impossible state: The counter (" + counter
+ ") has an impossible retract state (" + counter.state + ").");
}
}
@Override
public final void calculateScore() {
for (ExistsCounter<LeftTuple_> counter : dirtyCounterQueue) {
switch (counter.state) {
case CREATING:
nextNodesTupleLifecycle.insert(counter.leftTuple);
counter.state = BavetTupleState.OK;
break;
case UPDATING:
nextNodesTupleLifecycle.update(counter.leftTuple);
counter.state = BavetTupleState.OK;
break;
case DYING:
nextNodesTupleLifecycle.retract(counter.leftTuple);
counter.state = DEAD;
break;
case ABORTING:
counter.state = DEAD;
break;
case OK:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The dirty counter (" + counter
+ ") has an non-dirty state (" + counter.state + ").");
}
}
dirtyCounterQueue.clear();
}
protected static final class FilteringTracker<LeftTuple_ extends Tuple> {
final ExistsCounter<LeftTuple_> counter;
private final TupleListEntry<FilteringTracker<LeftTuple_>> leftTrackerEntry;
private final TupleListEntry<FilteringTracker<LeftTuple_>> rightTrackerEntry;
FilteringTracker(ExistsCounter<LeftTuple_> counter, TupleList<FilteringTracker<LeftTuple_>> leftTrackerList,
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList) {
this.counter = counter;
leftTrackerEntry = leftTrackerList.add(this);
rightTrackerEntry = rightTrackerList.add(this);
}
public void remove() {
leftTrackerEntry.remove();
rightTrackerEntry.remove();
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractIndexedIfExistsNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleList;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleListEntry;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
/**
* There is a strong likelihood that any change to this class, which is not related to indexing,
* should also be made to {@link AbstractUnindexedIfExistsNode}.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractIndexedIfExistsNode<LeftTuple_ extends Tuple, Right_>
extends AbstractIfExistsNode<LeftTuple_, Right_>
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
private final Function<Right_, IndexProperties> mappingRight;
private final int inputStoreIndexLeftProperties;
private final int inputStoreIndexLeftCounterEntry;
private final int inputStoreIndexRightProperties;
private final int inputStoreIndexRightEntry;
private final Indexer<ExistsCounter<LeftTuple_>> indexerLeft;
private final Indexer<UniTuple<Right_>> indexerRight;
protected AbstractIndexedIfExistsNode(boolean shouldExist,
Function<Right_, IndexProperties> mappingRight,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle,
Indexer<ExistsCounter<LeftTuple_>> indexerLeft,
Indexer<UniTuple<Right_>> indexerRight,
boolean isFiltering) {
super(shouldExist, inputStoreIndexLeftTrackerList, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, isFiltering);
this.mappingRight = mappingRight;
this.inputStoreIndexLeftProperties = inputStoreIndexLeftProperties;
this.inputStoreIndexLeftCounterEntry = inputStoreIndexLeftCounterEntry;
this.inputStoreIndexRightProperties = inputStoreIndexRightProperties;
this.inputStoreIndexRightEntry = inputStoreIndexRightEntry;
this.indexerLeft = indexerLeft;
this.indexerRight = indexerRight;
}
@Override
public final void insertLeft(LeftTuple_ leftTuple) {
if (leftTuple.getStore(inputStoreIndexLeftProperties) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + leftTuple
+ ") was already added in the tupleStore.");
}
IndexProperties indexProperties = createIndexProperties(leftTuple);
leftTuple.setStore(inputStoreIndexLeftProperties, indexProperties);
ExistsCounter<LeftTuple_> counter = new ExistsCounter<>(leftTuple);
TupleListEntry<ExistsCounter<LeftTuple_>> counterEntry = indexerLeft.put(indexProperties, counter);
leftTuple.setStore(inputStoreIndexLeftCounterEntry, counterEntry);
if (!isFiltering) {
counter.countRight = indexerRight.size(indexProperties);
} else {
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList = new TupleList<>();
indexerRight.forEach(indexProperties,
rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter, leftTrackerList));
leftTuple.setStore(inputStoreIndexLeftTrackerList, leftTrackerList);
}
initCounterLeft(counter);
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
IndexProperties oldIndexProperties = leftTuple.getStore(inputStoreIndexLeftProperties);
if (oldIndexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertLeft(leftTuple);
return;
}
IndexProperties newIndexProperties = createIndexProperties(leftTuple);
TupleListEntry<ExistsCounter<LeftTuple_>> counterEntry = leftTuple.getStore(inputStoreIndexLeftCounterEntry);
ExistsCounter<LeftTuple_> counter = counterEntry.getElement();
if (oldIndexProperties.equals(newIndexProperties)) {
// No need for re-indexing because the index properties didn't change
// The indexers contain counters in the DEAD state, to track the rightCount.
if (!isFiltering) {
updateUnchangedCounterLeft(counter);
} else {
// Call filtering for the leftTuple and rightTuple combinations again
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList = leftTuple.getStore(inputStoreIndexLeftTrackerList);
leftTrackerList.forEach(FilteringTracker::remove);
counter.countRight = 0;
indexerRight.forEach(oldIndexProperties,
rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter, leftTrackerList));
updateCounterLeft(counter);
}
} else {
updateIndexerLeft(oldIndexProperties, counterEntry, leftTuple);
counter.countRight = 0;
leftTuple.setStore(inputStoreIndexLeftProperties, newIndexProperties);
counterEntry = indexerLeft.put(newIndexProperties, counter);
leftTuple.setStore(inputStoreIndexLeftCounterEntry, counterEntry);
if (!isFiltering) {
counter.countRight = indexerRight.size(newIndexProperties);
} else {
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList = new TupleList<>();
indexerRight.forEach(newIndexProperties,
rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter, leftTrackerList));
leftTuple.setStore(inputStoreIndexLeftTrackerList, leftTrackerList);
}
updateCounterLeft(counter);
}
}
@Override
public final void retractLeft(LeftTuple_ leftTuple) {
IndexProperties indexProperties = leftTuple.removeStore(inputStoreIndexLeftProperties);
if (indexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
TupleListEntry<ExistsCounter<LeftTuple_>> counterEntry = leftTuple.getStore(inputStoreIndexLeftCounterEntry);
ExistsCounter<LeftTuple_> counter = counterEntry.getElement();
updateIndexerLeft(indexProperties, counterEntry, leftTuple);
killCounterLeft(counter);
}
private void updateIndexerLeft(IndexProperties indexProperties, TupleListEntry<ExistsCounter<LeftTuple_>> counterEntry,
LeftTuple_ leftTuple) {
indexerLeft.remove(indexProperties, counterEntry);
if (isFiltering) {
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList = leftTuple.getStore(inputStoreIndexLeftTrackerList);
leftTrackerList.forEach(FilteringTracker::remove);
}
}
@Override
public final void insertRight(UniTuple<Right_> rightTuple) {
if (rightTuple.getStore(inputStoreIndexRightProperties) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + rightTuple
+ ") was already added in the tupleStore.");
}
IndexProperties indexProperties = mappingRight.apply(rightTuple.getFactA());
rightTuple.setStore(inputStoreIndexRightProperties, indexProperties);
TupleListEntry<UniTuple<Right_>> rightEntry = indexerRight.put(indexProperties, rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
if (!isFiltering) {
indexerLeft.forEach(indexProperties, this::incrementCounterRight);
} else {
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList = new TupleList<>();
indexerLeft.forEach(indexProperties, counter -> updateCounterFromRight(rightTuple, counter, rightTrackerList));
rightTuple.setStore(inputStoreIndexRightTrackerList, rightTrackerList);
}
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
IndexProperties oldIndexProperties = rightTuple.getStore(inputStoreIndexRightProperties);
if (oldIndexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertRight(rightTuple);
return;
}
IndexProperties newIndexProperties = mappingRight.apply(rightTuple.getFactA());
if (oldIndexProperties.equals(newIndexProperties)) {
// No need for re-indexing because the index properties didn't change
if (isFiltering) {
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList = updateRightTrackerList(rightTuple);
indexerLeft.forEach(oldIndexProperties,
counter -> updateCounterFromRight(rightTuple, counter, rightTrackerList));
}
} else {
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.getStore(inputStoreIndexRightEntry);
indexerRight.remove(oldIndexProperties, rightEntry);
if (!isFiltering) {
indexerLeft.forEach(oldIndexProperties, this::decrementCounterRight);
} else {
updateRightTrackerList(rightTuple);
}
rightTuple.setStore(inputStoreIndexRightProperties, newIndexProperties);
rightEntry = indexerRight.put(newIndexProperties, rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
if (!isFiltering) {
indexerLeft.forEach(newIndexProperties, this::incrementCounterRight);
} else {
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList = new TupleList<>();
indexerLeft.forEach(newIndexProperties,
counter -> updateCounterFromRight(rightTuple, counter, rightTrackerList));
rightTuple.setStore(inputStoreIndexRightTrackerList, rightTrackerList);
}
}
}
@Override
public final void retractRight(UniTuple<Right_> rightTuple) {
IndexProperties indexProperties = rightTuple.removeStore(inputStoreIndexRightProperties);
if (indexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.removeStore(inputStoreIndexRightEntry);
indexerRight.remove(indexProperties, rightEntry);
if (!isFiltering) {
indexerLeft.forEach(indexProperties, this::decrementCounterRight);
} else {
updateRightTrackerList(rightTuple);
}
}
protected abstract IndexProperties createIndexProperties(LeftTuple_ leftTuple);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractIndexedJoinNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleList;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleListEntry;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
/**
* There is a strong likelihood that any change to this class, which is not related to indexing,
* should also be made to {@link AbstractUnindexedJoinNode}.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractIndexedJoinNode<LeftTuple_ extends Tuple, Right_, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_>
extends AbstractJoinNode<LeftTuple_, Right_, OutTuple_, MutableOutTuple_>
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
private final Function<Right_, IndexProperties> mappingRight;
private final int inputStoreIndexLeftProperties;
private final int inputStoreIndexLeftEntry;
private final int inputStoreIndexRightProperties;
private final int inputStoreIndexRightEntry;
/**
* Calls for example {@link AbstractScorer#insert(Tuple)} and/or ...
*/
private final Indexer<LeftTuple_> indexerLeft;
private final Indexer<UniTuple<Right_>> indexerRight;
protected AbstractIndexedJoinNode(Function<Right_, IndexProperties> mappingRight, int inputStoreIndexLeftProperties,
int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightProperties,
int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, boolean isFiltering, int outputStoreIndexLeftOutEntry,
int outputStoreIndexRightOutEntry, Indexer<LeftTuple_> indexerLeft, Indexer<UniTuple<Right_>> indexerRight) {
super(inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, nextNodesTupleLifecycle, isFiltering,
outputStoreIndexLeftOutEntry, outputStoreIndexRightOutEntry);
this.mappingRight = mappingRight;
this.inputStoreIndexLeftProperties = inputStoreIndexLeftProperties;
this.inputStoreIndexLeftEntry = inputStoreIndexLeftEntry;
this.inputStoreIndexRightProperties = inputStoreIndexRightProperties;
this.inputStoreIndexRightEntry = inputStoreIndexRightEntry;
this.indexerLeft = indexerLeft;
this.indexerRight = indexerRight;
}
@Override
public final void insertLeft(LeftTuple_ leftTuple) {
if (leftTuple.getStore(inputStoreIndexLeftProperties) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + leftTuple
+ ") was already added in the tupleStore.");
}
IndexProperties indexProperties = createIndexPropertiesLeft(leftTuple);
TupleList<MutableOutTuple_> outTupleListLeft = new TupleList<>();
leftTuple.setStore(inputStoreIndexLeftOutTupleList, outTupleListLeft);
indexAndPropagateLeft(leftTuple, indexProperties);
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
IndexProperties oldIndexProperties = leftTuple.getStore(inputStoreIndexLeftProperties);
if (oldIndexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertLeft(leftTuple);
return;
}
IndexProperties newIndexProperties = createIndexPropertiesLeft(leftTuple);
if (oldIndexProperties.equals(newIndexProperties)) {
// No need for re-indexing because the index properties didn't change
// Prefer an update over retract-insert if possible
innerUpdateLeft(leftTuple, consumer -> indexerRight.forEach(oldIndexProperties, consumer));
} else {
TupleListEntry<LeftTuple_> leftEntry = leftTuple.getStore(inputStoreIndexLeftEntry);
TupleList<MutableOutTuple_> outTupleListLeft = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
indexerLeft.remove(oldIndexProperties, leftEntry);
outTupleListLeft.forEach(this::retractOutTuple);
// outTupleListLeft is now empty
// No need for leftTuple.setStore(inputStoreIndexLeftOutTupleList, outTupleListLeft);
indexAndPropagateLeft(leftTuple, newIndexProperties);
}
}
private void indexAndPropagateLeft(LeftTuple_ leftTuple, IndexProperties indexProperties) {
leftTuple.setStore(inputStoreIndexLeftProperties, indexProperties);
TupleListEntry<LeftTuple_> leftEntry = indexerLeft.put(indexProperties, leftTuple);
leftTuple.setStore(inputStoreIndexLeftEntry, leftEntry);
indexerRight.forEach(indexProperties, rightTuple -> insertOutTupleFiltered(leftTuple, rightTuple));
}
@Override
public final void retractLeft(LeftTuple_ leftTuple) {
IndexProperties indexProperties = leftTuple.removeStore(inputStoreIndexLeftProperties);
if (indexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
TupleListEntry<LeftTuple_> leftEntry = leftTuple.removeStore(inputStoreIndexLeftEntry);
TupleList<MutableOutTuple_> outTupleListLeft = leftTuple.removeStore(inputStoreIndexLeftOutTupleList);
indexerLeft.remove(indexProperties, leftEntry);
outTupleListLeft.forEach(this::retractOutTuple);
}
@Override
public final void insertRight(UniTuple<Right_> rightTuple) {
if (rightTuple.getStore(inputStoreIndexRightProperties) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + rightTuple
+ ") was already added in the tupleStore.");
}
IndexProperties indexProperties = mappingRight.apply(rightTuple.getFactA());
TupleList<MutableOutTuple_> outTupleListRight = new TupleList<>();
rightTuple.setStore(inputStoreIndexRightOutTupleList, outTupleListRight);
indexAndPropagateRight(rightTuple, indexProperties);
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
IndexProperties oldIndexProperties = rightTuple.getStore(inputStoreIndexRightProperties);
if (oldIndexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertRight(rightTuple);
return;
}
IndexProperties newIndexProperties = mappingRight.apply(rightTuple.getFactA());
if (oldIndexProperties.equals(newIndexProperties)) {
// No need for re-indexing because the index properties didn't change
// Prefer an update over retract-insert if possible
innerUpdateRight(rightTuple, consumer -> indexerLeft.forEach(oldIndexProperties, consumer));
} else {
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.getStore(inputStoreIndexRightEntry);
TupleList<MutableOutTuple_> outTupleListRight = rightTuple.getStore(inputStoreIndexRightOutTupleList);
indexerRight.remove(oldIndexProperties, rightEntry);
outTupleListRight.forEach(this::retractOutTuple);
// outTupleListRight is now empty
// No need for rightTuple.setStore(inputStoreIndexRightOutTupleList, outTupleListRight);
indexAndPropagateRight(rightTuple, newIndexProperties);
}
}
private void indexAndPropagateRight(UniTuple<Right_> rightTuple, IndexProperties indexProperties) {
rightTuple.setStore(inputStoreIndexRightProperties, indexProperties);
TupleListEntry<UniTuple<Right_>> rightEntry = indexerRight.put(indexProperties, rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
indexerLeft.forEach(indexProperties, leftTuple -> insertOutTupleFiltered(leftTuple, rightTuple));
}
@Override
public final void retractRight(UniTuple<Right_> rightTuple) {
IndexProperties indexProperties = rightTuple.removeStore(inputStoreIndexRightProperties);
if (indexProperties == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.removeStore(inputStoreIndexRightEntry);
TupleList<MutableOutTuple_> outTupleListRight = rightTuple.removeStore(inputStoreIndexRightOutTupleList);
indexerRight.remove(indexProperties, rightEntry);
outTupleListRight.forEach(this::retractOutTuple);
}
protected abstract IndexProperties createIndexPropertiesLeft(LeftTuple_ leftTuple);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractJoinNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.ArrayDeque;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Queue;
import java.util.function.Consumer;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleList;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleListEntry;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
/**
* This class has two direct children: {@link AbstractIndexedJoinNode} and {@link AbstractUnindexedJoinNode}.
* The logic in either is identical, except that the latter removes all indexing work.
* Therefore any time that one of the classes changes,
* the other should be inspected if it could benefit from applying the change there too.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractJoinNode<LeftTuple_ extends Tuple, Right_, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_>
extends AbstractNode
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
protected final int inputStoreIndexLeftOutTupleList;
protected final int inputStoreIndexRightOutTupleList;
/**
* Calls for example {@link AbstractScorer#insert(Tuple)} and/or ...
*/
private final TupleLifecycle<OutTuple_> nextNodesTupleLifecycle;
private final boolean isFiltering;
private final int outputStoreIndexLeftOutEntry;
private final int outputStoreIndexRightOutEntry;
protected final Queue<OutTuple_> dirtyTupleQueue;
protected AbstractJoinNode(int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, boolean isFiltering,
int outputStoreIndexLeftOutEntry, int outputStoreIndexRightOutEntry) {
this.inputStoreIndexLeftOutTupleList = inputStoreIndexLeftOutTupleList;
this.inputStoreIndexRightOutTupleList = inputStoreIndexRightOutTupleList;
this.nextNodesTupleLifecycle = nextNodesTupleLifecycle;
this.isFiltering = isFiltering;
this.outputStoreIndexLeftOutEntry = outputStoreIndexLeftOutEntry;
this.outputStoreIndexRightOutEntry = outputStoreIndexRightOutEntry;
dirtyTupleQueue = new ArrayDeque<>(1000);
}
protected abstract MutableOutTuple_ createOutTuple(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple);
protected abstract void setOutTupleLeftFacts(MutableOutTuple_ outTuple, LeftTuple_ leftTuple);
protected abstract void setOutTupleRightFact(MutableOutTuple_ outTuple, UniTuple<Right_> rightTuple);
protected abstract boolean testFiltering(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple);
protected final void insertOutTuple(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple) {
MutableOutTuple_ outTuple = createOutTuple(leftTuple, rightTuple);
TupleList<MutableOutTuple_> outTupleListLeft = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
TupleListEntry<MutableOutTuple_> outEntryLeft = outTupleListLeft.add(outTuple);
outTuple.setStore(outputStoreIndexLeftOutEntry, outEntryLeft);
TupleList<MutableOutTuple_> outTupleListRight = rightTuple.getStore(inputStoreIndexRightOutTupleList);
TupleListEntry<MutableOutTuple_> outEntryRight = outTupleListRight.add(outTuple);
outTuple.setStore(outputStoreIndexRightOutEntry, outEntryRight);
dirtyTupleQueue.add(outTuple);
}
protected final void insertOutTupleFiltered(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple) {
if (!isFiltering || testFiltering(leftTuple, rightTuple)) {
insertOutTuple(leftTuple, rightTuple);
}
}
protected final void innerUpdateLeft(LeftTuple_ leftTuple, Consumer<Consumer<UniTuple<Right_>>> rightTupleConsumer) {
// Prefer an update over retract-insert if possible
TupleList<MutableOutTuple_> outTupleListLeft = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
if (!isFiltering) {
// Propagate the update for downstream filters, matchWeighers, ...
outTupleListLeft.forEach(outTuple -> updateOutTupleLeft(outTuple, leftTuple));
} else {
// Hack: the outTuple has no left/right input tuple reference, use the left/right outList reference instead
Map<TupleList<MutableOutTuple_>, MutableOutTuple_> rightToOutMap = new IdentityHashMap<>(outTupleListLeft.size());
outTupleListLeft.forEach(outTuple -> {
TupleListEntry<MutableOutTuple_> rightOutEntry = outTuple.getStore(outputStoreIndexRightOutEntry);
rightToOutMap.put(rightOutEntry.getList(), outTuple);
});
rightTupleConsumer.accept(rightTuple -> {
TupleList<MutableOutTuple_> rightOutList = rightTuple.getStore(inputStoreIndexRightOutTupleList);
processOutTupleUpdate(leftTuple, rightTuple, rightToOutMap, rightOutList);
});
}
}
private void updateOutTupleLeft(MutableOutTuple_ outTuple, LeftTuple_ leftTuple) {
setOutTupleLeftFacts(outTuple, leftTuple);
doUpdateOutTuple(outTuple);
}
private void doUpdateOutTuple(OutTuple_ outTuple) {
switch (outTuple.getState()) {
case CREATING:
case UPDATING:
// Don't add the tuple to the dirtyTupleQueue twice
break;
case OK:
outTuple.setState(BavetTupleState.UPDATING);
dirtyTupleQueue.add(outTuple);
break;
// Impossible because they shouldn't linger in the indexes
case DYING:
case ABORTING:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The tuple (" + outTuple.getState() + ") in node (" +
this + ") is in an unexpected state (" + outTuple.getState() + ").");
}
}
protected final void innerUpdateRight(UniTuple<Right_> rightTuple, Consumer<Consumer<LeftTuple_>> leftTupleConsumer) {
// Prefer an update over retract-insert if possible
TupleList<MutableOutTuple_> outTupleListRight = rightTuple.getStore(inputStoreIndexRightOutTupleList);
if (!isFiltering) {
// Propagate the update for downstream filters, matchWeighers, ...
outTupleListRight.forEach(outTuple -> {
setOutTupleRightFact(outTuple, rightTuple);
doUpdateOutTuple(outTuple);
});
} else {
// Hack: the outTuple has no left/right input tuple reference, use the left/right outList reference instead
Map<TupleList<MutableOutTuple_>, MutableOutTuple_> leftToOutMap = new IdentityHashMap<>(outTupleListRight.size());
outTupleListRight.forEach(outTuple -> {
TupleListEntry<MutableOutTuple_> leftOutEntry = outTuple.getStore(outputStoreIndexLeftOutEntry);
leftToOutMap.put(leftOutEntry.getList(), outTuple);
});
leftTupleConsumer.accept(leftTuple -> {
TupleList<MutableOutTuple_> leftOutList = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
processOutTupleUpdate(leftTuple, rightTuple, leftToOutMap, leftOutList);
});
}
}
private void processOutTupleUpdate(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple,
Map<TupleList<MutableOutTuple_>, MutableOutTuple_> outMap, TupleList<MutableOutTuple_> outList) {
MutableOutTuple_ outTuple = outMap.get(outList);
if (testFiltering(leftTuple, rightTuple)) {
if (outTuple == null) {
insertOutTuple(leftTuple, rightTuple);
} else {
updateOutTupleLeft(outTuple, leftTuple);
}
} else {
if (outTuple != null) {
retractOutTuple(outTuple);
}
}
}
protected final void retractOutTuple(MutableOutTuple_ outTuple) {
TupleListEntry<MutableOutTuple_> outEntryLeft = outTuple.removeStore(outputStoreIndexLeftOutEntry);
outEntryLeft.remove();
TupleListEntry<MutableOutTuple_> outEntryRight = outTuple.removeStore(outputStoreIndexRightOutEntry);
outEntryRight.remove();
switch (outTuple.getState()) {
case CREATING:
// Don't add the tuple to the dirtyTupleQueue twice
// Kill it before it propagates
outTuple.setState(BavetTupleState.ABORTING);
break;
case OK:
outTuple.setState(BavetTupleState.DYING);
dirtyTupleQueue.add(outTuple);
break;
case UPDATING:
// Don't add the tuple to the dirtyTupleQueue twice
// Kill the original propagation
outTuple.setState(BavetTupleState.DYING);
break;
// Impossible because they shouldn't linger in the indexes
case DYING:
case ABORTING:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The tuple (" + outTuple.getState() + ") in node (" +
this + ") is in an unexpected state (" + outTuple.getState() + ").");
}
}
@Override
public final void calculateScore() {
for (OutTuple_ tuple : dirtyTupleQueue) {
switch (tuple.getState()) {
case CREATING:
nextNodesTupleLifecycle.insert(tuple);
tuple.setState(BavetTupleState.OK);
break;
case UPDATING:
nextNodesTupleLifecycle.update(tuple);
tuple.setState(BavetTupleState.OK);
break;
case DYING:
nextNodesTupleLifecycle.retract(tuple);
tuple.setState(BavetTupleState.DEAD);
break;
case ABORTING:
tuple.setState(BavetTupleState.DEAD);
break;
case OK:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The tuple (" + tuple + ") in node (" +
this + ") is in an unexpected state (" + tuple.getState() + ").");
}
}
dirtyTupleQueue.clear();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractMapNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.ArrayDeque;
import java.util.Queue;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTupleImpl;
public abstract class AbstractMapNode<InTuple_ extends Tuple, Right_>
extends AbstractNode
implements TupleLifecycle<InTuple_> {
private final int inputStoreIndex;
/**
* Calls for example {@link AbstractScorer#insert(Tuple)} and/or ...
*/
private final TupleLifecycle<UniTuple<Right_>> nextNodesTupleLifecycle;
private final int outputStoreSize;
private final Queue<UniTuple<Right_>> dirtyTupleQueue;
protected AbstractMapNode(int inputStoreIndex, TupleLifecycle<UniTuple<Right_>> nextNodesTupleLifecycle,
int outputStoreSize) {
this.inputStoreIndex = inputStoreIndex;
this.nextNodesTupleLifecycle = nextNodesTupleLifecycle;
this.outputStoreSize = outputStoreSize;
dirtyTupleQueue = new ArrayDeque<>(1000);
}
@Override
public void insert(InTuple_ tuple) {
if (tuple.getStore(inputStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
Right_ mapped = map(tuple);
UniTuple<Right_> outTuple = new UniTupleImpl<>(mapped, outputStoreSize);
tuple.setStore(inputStoreIndex, outTuple);
dirtyTupleQueue.add(outTuple);
}
protected abstract Right_ map(InTuple_ tuple);
@Override
public void update(InTuple_ tuple) {
UniTupleImpl<Right_> outTuple = tuple.getStore(inputStoreIndex);
if (outTuple == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insert(tuple);
return;
}
Right_ oldMapped = outTuple.factA;
Right_ mapped = map(tuple);
// We check for identity, not equality, to not introduce dependency on user equals().
if (mapped != oldMapped) {
outTuple.factA = mapped;
outTuple.state = BavetTupleState.UPDATING;
dirtyTupleQueue.add(outTuple);
}
}
@Override
public void retract(InTuple_ tuple) {
UniTuple<Right_> outTuple = tuple.removeStore(inputStoreIndex);
if (outTuple == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
outTuple.setState(BavetTupleState.DYING);
dirtyTupleQueue.add(outTuple);
}
@Override
public void calculateScore() {
for (UniTuple<Right_> tuple : dirtyTupleQueue) {
switch (tuple.getState()) {
case CREATING:
nextNodesTupleLifecycle.insert(tuple);
tuple.setState(BavetTupleState.OK);
break;
case UPDATING:
nextNodesTupleLifecycle.update(tuple);
tuple.setState(BavetTupleState.OK);
break;
case DYING:
nextNodesTupleLifecycle.retract(tuple);
tuple.setState(BavetTupleState.DEAD);
break;
case ABORTING:
tuple.setState(BavetTupleState.DEAD);
break;
case OK:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The tuple (" + tuple + ") in node (" +
this + ") is in an unexpected state (" + tuple.getState() + ").");
}
}
dirtyTupleQueue.clear();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
public abstract class AbstractNode {
private long id;
public abstract void calculateScore();
public void setId(long id) {
this.id = id;
}
@Override
public String toString() {
// Useful for debugging if a constraint has multiple nodes of the same type
return getClass().getSimpleName() + "-" + id;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractScorer.java | package ai.timefold.solver.constraint.streams.bavet.common;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatchTotal;
public abstract class AbstractScorer<Tuple_ extends Tuple> implements TupleLifecycle<Tuple_> {
private final String constraintId;
private final Score<?> constraintWeight;
private final int inputStoreIndex;
protected AbstractScorer(String constraintPackage, String constraintName,
Score<?> constraintWeight, int inputStoreIndex) {
this.constraintId = ConstraintMatchTotal.composeConstraintId(constraintPackage, constraintName);
this.constraintWeight = constraintWeight;
this.inputStoreIndex = inputStoreIndex;
}
@Override
public final void insert(Tuple_ tuple) {
if (tuple.getStore(inputStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
tuple.setStore(inputStoreIndex, impact(tuple));
}
@Override
public final void update(Tuple_ tuple) {
UndoScoreImpacter undoScoreImpacter = tuple.getStore(inputStoreIndex);
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
if (undoScoreImpacter != null) {
undoScoreImpacter.run();
}
tuple.setStore(inputStoreIndex, impact(tuple));
}
protected abstract UndoScoreImpacter impact(Tuple_ tuple);
/**
* Helps with debugging exceptions thrown by user code during impact calls.
*
* @param tuple never null
* @param cause never null
* @return never null, exception to be thrown.
*/
protected RuntimeException createExceptionOnImpact(Tuple_ tuple, Exception cause) {
return new IllegalStateException(
"Consequence of a constraint (" + constraintId + ") threw an exception processing a tuple (" + tuple + ").",
cause);
}
@Override
public final void retract(Tuple_ tuple) {
UndoScoreImpacter undoScoreImpacter = tuple.getStore(inputStoreIndex);
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
if (undoScoreImpacter != null) {
undoScoreImpacter.run();
tuple.setStore(inputStoreIndex, null);
}
}
@Override
public final String toString() {
return getClass().getSimpleName() + "(" + constraintId + ") with constraintWeight (" + constraintWeight + ")";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/AbstractTuple.java | package ai.timefold.solver.constraint.streams.bavet.common;
public abstract class AbstractTuple implements Tuple {
/*
* We create a lot of tuples, many of them having store size of 1.
* If an array of size 1 was created for each such tuple, memory would be wasted and indirection created.
* This trade-off of increased memory efficiency for marginally slower access time is proven beneficial.
*/
private final boolean storeIsArray;
private Object store;
public BavetTupleState state = BavetTupleState.CREATING;
protected AbstractTuple(int storeSize) {
this.store = (storeSize < 2) ? null : new Object[storeSize];
this.storeIsArray = store != null;
}
@Override
public final BavetTupleState getState() {
return state;
}
@Override
public final void setState(BavetTupleState state) {
this.state = state;
}
@Override
public final <Value_> Value_ getStore(int index) {
if (storeIsArray) {
return (Value_) ((Object[]) store)[index];
}
return (Value_) store;
}
@Override
public final void setStore(int index, Object value) {
if (storeIsArray) {
((Object[]) store)[index] = value;
return;
}
store = value;
}
@Override
public <Value_> Value_ removeStore(int index) {
Value_ value;
if (storeIsArray) {
Object[] array = (Object[]) store;
value = (Value_) array[index];
array[index] = null;
} else {
value = (Value_) store;
store = null;
}
return value;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.