index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
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/AbstractUnindexedIfExistsNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
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;
/**
* There is a strong likelihood that any change made to this class
* should also be made to {@link AbstractIndexedIfExistsNode}.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractUnindexedIfExistsNode<LeftTuple_ extends Tuple, Right_>
extends AbstractIfExistsNode<LeftTuple_, Right_>
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
private final int inputStoreIndexLeftCounterEntry;
private final int inputStoreIndexRightEntry;
// Acts as a leftTupleList too
private final TupleList<ExistsCounter<LeftTuple_>> leftCounterList = new TupleList<>();
private final TupleList<UniTuple<Right_>> rightTupleList = new TupleList<>();
protected AbstractUnindexedIfExistsNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle,
boolean isFiltering) {
super(shouldExist, inputStoreIndexLeftTrackerList, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, isFiltering);
this.inputStoreIndexLeftCounterEntry = inputStoreIndexLeftCounterEntry;
this.inputStoreIndexRightEntry = inputStoreIndexRightEntry;
}
@Override
public final void insertLeft(LeftTuple_ leftTuple) {
if (leftTuple.getStore(inputStoreIndexLeftCounterEntry) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + leftTuple
+ ") was already added in the tupleStore.");
}
ExistsCounter<LeftTuple_> counter = new ExistsCounter<>(leftTuple);
TupleListEntry<ExistsCounter<LeftTuple_>> counterEntry = leftCounterList.add(counter);
leftTuple.setStore(inputStoreIndexLeftCounterEntry, counterEntry);
if (!isFiltering) {
counter.countRight = rightTupleList.size();
} else {
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList = new TupleList<>();
rightTupleList.forEach(rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter, leftTrackerList));
leftTuple.setStore(inputStoreIndexLeftTrackerList, leftTrackerList);
}
initCounterLeft(counter);
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
TupleListEntry<ExistsCounter<LeftTuple_>> counterEntry = leftTuple.getStore(inputStoreIndexLeftCounterEntry);
if (counterEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertLeft(leftTuple);
return;
}
ExistsCounter<LeftTuple_> counter = counterEntry.getElement();
// 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;
rightTupleList.forEach(rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter, leftTrackerList));
updateCounterLeft(counter);
}
}
@Override
public final void retractLeft(LeftTuple_ leftTuple) {
TupleListEntry<ExistsCounter<LeftTuple_>> counterEntry = leftTuple.removeStore(inputStoreIndexLeftCounterEntry);
if (counterEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
ExistsCounter<LeftTuple_> counter = counterEntry.getElement();
counterEntry.remove();
if (isFiltering) {
TupleList<FilteringTracker<LeftTuple_>> leftTrackerList = leftTuple.getStore(inputStoreIndexLeftTrackerList);
leftTrackerList.forEach(FilteringTracker::remove);
}
killCounterLeft(counter);
}
@Override
public final void insertRight(UniTuple<Right_> rightTuple) {
if (rightTuple.getStore(inputStoreIndexRightEntry) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + rightTuple
+ ") was already added in the tupleStore.");
}
TupleListEntry<UniTuple<Right_>> rightEntry = rightTupleList.add(rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
if (!isFiltering) {
leftCounterList.forEach(this::incrementCounterRight);
} else {
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList = new TupleList<>();
leftCounterList.forEach(counter -> updateCounterFromRight(rightTuple, counter, rightTrackerList));
rightTuple.setStore(inputStoreIndexRightTrackerList, rightTrackerList);
}
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.getStore(inputStoreIndexRightEntry);
if (rightEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertRight(rightTuple);
return;
}
if (isFiltering) {
TupleList<FilteringTracker<LeftTuple_>> rightTrackerList = updateRightTrackerList(rightTuple);
leftCounterList.forEach(counter -> updateCounterFromRight(rightTuple, counter, rightTrackerList));
}
}
@Override
public final void retractRight(UniTuple<Right_> rightTuple) {
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.removeStore(inputStoreIndexRightEntry);
if (rightEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
rightEntry.remove();
if (!isFiltering) {
leftCounterList.forEach(this::decrementCounterRight);
} else {
updateRightTrackerList(rightTuple);
}
}
}
|
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/AbstractUnindexedJoinNode.java | package ai.timefold.solver.constraint.streams.bavet.common;
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;
/**
* There is a strong likelihood that any change made to this class
* should also be made to {@link AbstractIndexedJoinNode}.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractUnindexedJoinNode<LeftTuple_ extends Tuple, Right_, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_>
extends AbstractJoinNode<LeftTuple_, Right_, OutTuple_, MutableOutTuple_>
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
private final int inputStoreIndexLeftEntry;
private final int inputStoreIndexRightEntry;
private final TupleList<LeftTuple_> leftTupleList = new TupleList<>();
private final TupleList<UniTuple<Right_>> rightTupleList = new TupleList<>();
protected AbstractUnindexedJoinNode(int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, boolean isFiltering, int outputStoreIndexLeftOutEntry,
int outputStoreIndexRightOutEntry) {
super(inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, nextNodesTupleLifecycle, isFiltering,
outputStoreIndexLeftOutEntry, outputStoreIndexRightOutEntry);
this.inputStoreIndexLeftEntry = inputStoreIndexLeftEntry;
this.inputStoreIndexRightEntry = inputStoreIndexRightEntry;
}
@Override
public final void insertLeft(LeftTuple_ leftTuple) {
if (leftTuple.getStore(inputStoreIndexLeftEntry) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + leftTuple
+ ") was already added in the tupleStore.");
}
TupleListEntry<LeftTuple_> leftEntry = leftTupleList.add(leftTuple);
leftTuple.setStore(inputStoreIndexLeftEntry, leftEntry);
TupleList<MutableOutTuple_> outTupleListLeft = new TupleList<>();
leftTuple.setStore(inputStoreIndexLeftOutTupleList, outTupleListLeft);
rightTupleList.forEach(rightTuple -> insertOutTupleFiltered(leftTuple, rightTuple));
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
TupleListEntry<LeftTuple_> leftEntry = leftTuple.getStore(inputStoreIndexLeftEntry);
if (leftEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertLeft(leftTuple);
return;
}
innerUpdateLeft(leftTuple, rightTupleList::forEach);
}
@Override
public final void retractLeft(LeftTuple_ leftTuple) {
TupleListEntry<LeftTuple_> leftEntry = leftTuple.removeStore(inputStoreIndexLeftEntry);
if (leftEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
TupleList<MutableOutTuple_> outTupleListLeft = leftTuple.removeStore(inputStoreIndexLeftOutTupleList);
leftEntry.remove();
outTupleListLeft.forEach(this::retractOutTuple);
}
@Override
public final void insertRight(UniTuple<Right_> rightTuple) {
if (rightTuple.getStore(inputStoreIndexRightEntry) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + rightTuple
+ ") was already added in the tupleStore.");
}
TupleListEntry<UniTuple<Right_>> rightEntry = rightTupleList.add(rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
TupleList<MutableOutTuple_> outTupleListRight = new TupleList<>();
rightTuple.setStore(inputStoreIndexRightOutTupleList, outTupleListRight);
leftTupleList.forEach(leftTuple -> insertOutTupleFiltered(leftTuple, rightTuple));
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.getStore(inputStoreIndexRightEntry);
if (rightEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertRight(rightTuple);
return;
}
innerUpdateRight(rightTuple, leftTupleList::forEach);
}
@Override
public final void retractRight(UniTuple<Right_> rightTuple) {
TupleListEntry<UniTuple<Right_>> rightEntry = rightTuple.removeStore(inputStoreIndexRightEntry);
if (rightEntry == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
TupleList<MutableOutTuple_> outTupleListRight = rightTuple.removeStore(inputStoreIndexRightOutTupleList);
rightEntry.remove();
outTupleListRight.forEach(this::retractOutTuple);
}
}
|
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/AggregatedTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common;
final class AggregatedTupleLifecycle<Tuple_ extends Tuple> implements TupleLifecycle<Tuple_> {
private final TupleLifecycle<Tuple_>[] lifecycles;
public AggregatedTupleLifecycle(TupleLifecycle<Tuple_>[] lifecycles) {
this.lifecycles = lifecycles;
}
@Override
public void insert(Tuple_ tuple) {
for (TupleLifecycle<Tuple_> lifecycle : lifecycles) {
lifecycle.insert(tuple);
}
}
@Override
public void update(Tuple_ tuple) {
for (TupleLifecycle<Tuple_> lifecycle : lifecycles) {
lifecycle.update(tuple);
}
}
@Override
public void retract(Tuple_ tuple) {
for (TupleLifecycle<Tuple_> lifecycle : lifecycles) {
lifecycle.retract(tuple);
}
}
@Override
public String toString() {
return "size = " + lifecycles.length;
}
}
|
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/BavetAbstractConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraint;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintStream;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
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.uni.UniConstraintStream;
public abstract class BavetAbstractConstraintStream<Solution_> extends AbstractConstraintStream<Solution_> {
protected final BavetConstraintFactory<Solution_> constraintFactory;
public BavetAbstractConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(retrievalSemantics);
this.constraintFactory = constraintFactory;
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
protected Constraint buildConstraint(String constraintPackage, String constraintName, Score<?> constraintWeight,
ScoreImpactType impactType, Object justificationFunction, Object indictedObjectsMapping,
BavetScoringConstraintStream<Solution_> stream) {
var resolvedConstraintPackage =
Objects.requireNonNullElseGet(constraintPackage, this.constraintFactory::getDefaultConstraintPackage);
var resolvedJustificationMapping =
Objects.requireNonNullElseGet(justificationFunction, this::getDefaultJustificationMapping);
var resolvedIndictedObjectsMapping =
Objects.requireNonNullElseGet(indictedObjectsMapping, this::getDefaultIndictedObjectsMapping);
var isConstraintWeightConfigurable = constraintWeight == null;
var constraintWeightExtractor = isConstraintWeightConfigurable
? buildConstraintWeightExtractor(resolvedConstraintPackage, constraintName)
: buildConstraintWeightExtractor(resolvedConstraintPackage, constraintName, constraintWeight);
var constraint =
new BavetConstraint<>(constraintFactory, resolvedConstraintPackage, constraintName, constraintWeightExtractor,
impactType, resolvedJustificationMapping, resolvedIndictedObjectsMapping,
isConstraintWeightConfigurable, stream);
stream.setConstraint(constraint);
return constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
public abstract void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet);
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return this;
}
public abstract <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper);
// ************************************************************************
// Helper methods
// ************************************************************************
protected <A> BavetAbstractUniConstraintStream<Solution_, A> assertBavetUniConstraintStream(
UniConstraintStream<A> otherStream) {
if (!(otherStream instanceof BavetAbstractUniConstraintStream)) {
throw new IllegalStateException("The streams (" + this + ", " + otherStream
+ ") are not built from the same " + ConstraintFactory.class.getSimpleName() + ".");
}
BavetAbstractUniConstraintStream<Solution_, A> other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
if (constraintFactory != other.getConstraintFactory()) {
throw new IllegalStateException("The streams (" + this + ", " + other
+ ") are built from different constraintFactories (" + constraintFactory + ", "
+ other.getConstraintFactory()
+ ").");
}
return other;
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetConstraintFactory<Solution_> getConstraintFactory() {
return constraintFactory;
}
}
|
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/BavetJoinConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common;
public interface BavetJoinConstraintStream<Solution_> {
}
|
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/BavetTupleState.java | package ai.timefold.solver.constraint.streams.bavet.common;
public enum BavetTupleState {
CREATING(true, true),
UPDATING(true, true),
/**
* Freshly refreshed tuple.
*/
OK(false, true),
/**
* Tuple which was {@link #UPDATING} and then invalidated by subsequent tuple.
*/
DYING(true, false),
DEAD(false, false),
/**
* Tuple which was {@link #CREATING} and then invalidated by subsequent tuple.
*/
ABORTING(true, false);
private final boolean dirty;
private final boolean active;
BavetTupleState(boolean dirty, boolean active) {
this.dirty = dirty;
this.active = active;
}
public boolean isDirty() {
return dirty;
}
public boolean isActive() {
return active;
}
}
|
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/ExistsCounter.java | package ai.timefold.solver.constraint.streams.bavet.common;
import static ai.timefold.solver.constraint.streams.bavet.common.BavetTupleState.DEAD;
public final class ExistsCounter<Tuple_ extends Tuple> {
final Tuple_ leftTuple;
BavetTupleState state = DEAD;
int countRight = 0;
ExistsCounter(Tuple_ leftTuple) {
this.leftTuple = leftTuple;
}
@Override
public String toString() {
return "Counter(" + 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/GroupNodeConstructor.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.List;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
public interface GroupNodeConstructor<Tuple_ extends Tuple> {
static <Tuple_ extends Tuple> GroupNodeConstructor<Tuple_>
of(NodeConstructorWithAccumulate<Tuple_> nodeConstructorWithAccumulate) {
return new GroupNodeConstructorWithAccumulate<>(nodeConstructorWithAccumulate);
}
static <Tuple_ extends Tuple> GroupNodeConstructor<Tuple_>
of(NodeConstructorWithoutAccumulate<Tuple_> nodeConstructorWithoutAccumulate) {
return new GroupNodeConstructorWithoutAccumulate<>(nodeConstructorWithoutAccumulate);
}
@FunctionalInterface
interface NodeConstructorWithAccumulate<Tuple_ extends Tuple> {
AbstractNode apply(int groupStoreIndex, int undoStoreIndex, TupleLifecycle<Tuple_> nextNodesTupleLifecycle,
int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface NodeConstructorWithoutAccumulate<Tuple_ extends Tuple> {
AbstractNode apply(int groupStoreIndex, TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode);
}
<Solution_, Score_ extends Score<Score_>> void build(NodeBuildHelper<Score_> buildHelper,
BavetAbstractConstraintStream<Solution_> parentTupleSource,
BavetAbstractConstraintStream<Solution_> groupStream, List<? extends ConstraintStream> groupStreamChildList,
BavetAbstractConstraintStream<Solution_> thisStream,
List<? extends ConstraintStream> thisStreamChildList, EnvironmentMode 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/common/GroupNodeConstructorWithAccumulate.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.List;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class GroupNodeConstructorWithAccumulate<Tuple_ extends Tuple> implements GroupNodeConstructor<Tuple_> {
private final NodeConstructorWithAccumulate<Tuple_> nodeConstructorFunction;
public GroupNodeConstructorWithAccumulate(NodeConstructorWithAccumulate<Tuple_> nodeConstructorFunction) {
this.nodeConstructorFunction = nodeConstructorFunction;
}
@Override
public <Solution_, Score_ extends Score<Score_>> void build(NodeBuildHelper<Score_> buildHelper,
BavetAbstractConstraintStream<Solution_> parentTupleSource,
BavetAbstractConstraintStream<Solution_> groupStream, List<? extends ConstraintStream> groupStreamChildList,
BavetAbstractConstraintStream<Solution_> bridgeStream, List<? extends ConstraintStream> bridgeStreamChildList,
EnvironmentMode environmentMode) {
if (!bridgeStreamChildList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + bridgeStream
+ ") has an non-empty childStreamList (" + bridgeStreamChildList + ") but it's a groupBy bridge.");
}
int groupStoreIndex = buildHelper.reserveTupleStoreIndex(parentTupleSource);
int undoStoreIndex = buildHelper.reserveTupleStoreIndex(parentTupleSource);
TupleLifecycle<Tuple_> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(groupStreamChildList);
int outputStoreSize = buildHelper.extractTupleStoreSize(groupStream);
var node = nodeConstructorFunction.apply(groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode);
buildHelper.addNode(node, bridgeStream);
}
}
|
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/GroupNodeConstructorWithoutAccumulate.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.List;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class GroupNodeConstructorWithoutAccumulate<Tuple_ extends Tuple> implements GroupNodeConstructor<Tuple_> {
private final NodeConstructorWithoutAccumulate<Tuple_> nodeConstructorFunction;
public GroupNodeConstructorWithoutAccumulate(NodeConstructorWithoutAccumulate<Tuple_> nodeConstructorFunction) {
this.nodeConstructorFunction = nodeConstructorFunction;
}
@Override
public <Solution_, Score_ extends Score<Score_>> void build(NodeBuildHelper<Score_> buildHelper,
BavetAbstractConstraintStream<Solution_> parentTupleSource,
BavetAbstractConstraintStream<Solution_> groupStream, List<? extends ConstraintStream> groupStreamChildList,
BavetAbstractConstraintStream<Solution_> bridgeStream, List<? extends ConstraintStream> bridgeStreamChildList,
EnvironmentMode environmentMode) {
if (!bridgeStreamChildList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + bridgeStream
+ ") has an non-empty childStreamList (" + bridgeStreamChildList + ") but it's a groupBy bridge.");
}
int groupStoreIndex = buildHelper.reserveTupleStoreIndex(parentTupleSource);
TupleLifecycle<Tuple_> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(groupStreamChildList);
int outputStoreSize = buildHelper.extractTupleStoreSize(groupStream);
var node = nodeConstructorFunction.apply(groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode);
buildHelper.addNode(node, bridgeStream);
}
}
|
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/GroupWithAccumulate.java | package ai.timefold.solver.constraint.streams.bavet.common;
final class GroupWithAccumulate<OutTuple_ extends Tuple, ResultContainer_>
extends AbstractGroup<OutTuple_, ResultContainer_> {
private final ResultContainer_ resultContainer;
public GroupWithAccumulate(Object groupKey, ResultContainer_ resultContainer, OutTuple_ outTuple) {
super(groupKey, outTuple);
this.resultContainer = resultContainer;
}
@Override
public ResultContainer_ getResultContainer() {
return resultContainer;
}
}
|
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/GroupWithoutAccumulate.java | package ai.timefold.solver.constraint.streams.bavet.common;
final class GroupWithoutAccumulate<OutTuple_ extends Tuple, ResultContainer_>
extends AbstractGroup<OutTuple_, ResultContainer_> {
public GroupWithoutAccumulate(Object groupKey, OutTuple_ outTuple) {
super(groupKey, outTuple);
}
@Override
public ResultContainer_ getResultContainer() {
throw new UnsupportedOperationException();
}
}
|
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/LeftTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common;
public interface LeftTupleLifecycle<Tuple_ extends Tuple> {
void insertLeft(Tuple_ tuple);
void updateLeft(Tuple_ tuple);
void retractLeft(Tuple_ tuple);
}
|
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/LeftTupleLifecycleImpl.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.Objects;
final class LeftTupleLifecycleImpl<Tuple_ extends Tuple>
implements TupleLifecycle<Tuple_> {
private final LeftTupleLifecycle<Tuple_> leftTupleLifecycle;
LeftTupleLifecycleImpl(LeftTupleLifecycle<Tuple_> leftTupleLifecycle) {
this.leftTupleLifecycle = Objects.requireNonNull(leftTupleLifecycle);
}
@Override
public void insert(Tuple_ tuple) {
leftTupleLifecycle.insertLeft(tuple);
}
@Override
public void update(Tuple_ tuple) {
leftTupleLifecycle.updateLeft(tuple);
}
@Override
public void retract(Tuple_ tuple) {
leftTupleLifecycle.retractLeft(tuple);
}
@Override
public String toString() {
return "left " + leftTupleLifecycle;
}
}
|
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/NodeBuildHelper.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintStream;
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.ConstraintStream;
public final class NodeBuildHelper<Score_ extends Score<Score_>> {
private final Set<? extends ConstraintStream> activeStreamSet;
private final Map<Constraint, Score_> constraintWeightMap;
private final AbstractScoreInliner<Score_> scoreInliner;
private final Map<ConstraintStream, TupleLifecycle<? extends Tuple>> tupleLifecycleMap;
private final Map<ConstraintStream, Integer> storeIndexMap;
private List<AbstractNode> reversedNodeList;
public NodeBuildHelper(Set<? extends ConstraintStream> activeStreamSet, Map<Constraint, Score_> constraintWeightMap,
AbstractScoreInliner<Score_> scoreInliner) {
this.activeStreamSet = activeStreamSet;
this.constraintWeightMap = constraintWeightMap;
this.scoreInliner = scoreInliner;
int activeStreamSetSize = activeStreamSet.size();
this.tupleLifecycleMap = new HashMap<>(Math.max(16, activeStreamSetSize));
this.storeIndexMap = new HashMap<>(Math.max(16, activeStreamSetSize / 2));
this.reversedNodeList = new ArrayList<>(activeStreamSetSize);
}
public boolean isStreamActive(ConstraintStream stream) {
return activeStreamSet.contains(stream);
}
public AbstractScoreInliner<Score_> getScoreInliner() {
return scoreInliner;
}
public Score_ getConstraintWeight(Constraint constraint) {
return constraintWeightMap.get(constraint);
}
public void addNode(AbstractNode node) {
reversedNodeList.add(node);
}
public void addNode(AbstractNode node, ConstraintStream parent) {
addNode(node);
putInsertUpdateRetract(parent, (TupleLifecycle<? extends Tuple>) node);
}
public void addNode(AbstractNode node, ConstraintStream leftParent, ConstraintStream rightParent) {
addNode(node);
putInsertUpdateRetract(leftParent, TupleLifecycle.ofLeft((LeftTupleLifecycle<? extends Tuple>) node));
putInsertUpdateRetract(rightParent, TupleLifecycle.ofRight((RightTupleLifecycle<? extends Tuple>) node));
}
public <Tuple_ extends Tuple> void putInsertUpdateRetract(ConstraintStream stream, TupleLifecycle<Tuple_> tupleLifecycle) {
tupleLifecycleMap.put(stream, tupleLifecycle);
}
public <Tuple_ extends Tuple> void putInsertUpdateRetract(ConstraintStream stream,
List<? extends AbstractConstraintStream> childStreamList,
Function<TupleLifecycle<Tuple_>, AbstractConditionalTupleLifecycle<Tuple_>> tupleLifecycleFunction) {
TupleLifecycle<Tuple_> tupleLifecycle = getAggregatedTupleLifecycle(childStreamList);
putInsertUpdateRetract(stream, tupleLifecycleFunction.apply(tupleLifecycle));
}
public <Tuple_ extends Tuple> TupleLifecycle<Tuple_> getAggregatedTupleLifecycle(
List<? extends ConstraintStream> streamList) {
TupleLifecycle<Tuple_>[] tupleLifecycles = streamList.stream()
.filter(this::isStreamActive)
.map(s -> getTupleLifecycle(s, tupleLifecycleMap))
.toArray(TupleLifecycle[]::new);
switch (tupleLifecycles.length) {
case 0:
throw new IllegalStateException("Impossible state: None of the streamList (" + streamList
+ ") are active.");
case 1:
return tupleLifecycles[0];
default:
return new AggregatedTupleLifecycle<>(tupleLifecycles);
}
}
private static <Tuple_ extends Tuple> TupleLifecycle<Tuple_> getTupleLifecycle(ConstraintStream stream,
Map<ConstraintStream, TupleLifecycle<? extends Tuple>> tupleLifecycleMap) {
TupleLifecycle<Tuple_> tupleLifecycle = (TupleLifecycle<Tuple_>) tupleLifecycleMap.get(stream);
if (tupleLifecycle == null) {
throw new IllegalStateException("Impossible state: the stream (" + stream + ") hasn't built a node yet.");
}
return tupleLifecycle;
}
public int reserveTupleStoreIndex(ConstraintStream tupleSourceStream) {
return storeIndexMap.compute(tupleSourceStream, (k, index) -> {
if (index == null) {
return 0;
} else if (index < 0) {
throw new IllegalStateException("Impossible state: the tupleSourceStream (" + k
+ ") is reserving a store after it has been extracted.");
} else {
return index + 1;
}
});
}
public int extractTupleStoreSize(ConstraintStream tupleSourceStream) {
Integer lastIndex = storeIndexMap.put(tupleSourceStream, Integer.MIN_VALUE);
return (lastIndex == null) ? 0 : lastIndex + 1;
}
public List<AbstractNode> destroyAndGetNodeList() {
List<AbstractNode> nodeList = this.reversedNodeList;
Collections.reverse(nodeList);
this.reversedNodeList = null;
return nodeList;
}
}
|
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/RightTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common;
public interface RightTupleLifecycle<Tuple_ extends Tuple> {
void insertRight(Tuple_ tuple);
void updateRight(Tuple_ tuple);
void retractRight(Tuple_ tuple);
}
|
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/RightTupleLifecycleImpl.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.Objects;
final class RightTupleLifecycleImpl<Tuple_ extends Tuple>
implements TupleLifecycle<Tuple_> {
private final RightTupleLifecycle<Tuple_> rightTupleLifecycle;
RightTupleLifecycleImpl(RightTupleLifecycle<Tuple_> rightTupleLifecycle) {
this.rightTupleLifecycle = Objects.requireNonNull(rightTupleLifecycle);
}
@Override
public void insert(Tuple_ tuple) {
rightTupleLifecycle.insertRight(tuple);
}
@Override
public void update(Tuple_ tuple) {
rightTupleLifecycle.updateRight(tuple);
}
@Override
public void retract(Tuple_ tuple) {
rightTupleLifecycle.retractRight(tuple);
}
@Override
public String toString() {
return "right " + rightTupleLifecycle;
}
}
|
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/Tuple.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
/**
* A tuple is an <i>out tuple</i> in exactly one node and an <i>in tuple</i> in one or more nodes.
* <p/>
* A tuple must not implement equals()/hashCode() to fact equality,
* because some stream operations ({@link UniConstraintStream#map(Function)}, ...)
* might create 2 different tuple instances to contain the same facts
* and because a tuple's origin may replace a tuple's fact.
*/
public interface Tuple {
BavetTupleState getState();
void setState(BavetTupleState state);
<Value_> Value_ getStore(int index);
void setStore(int index, Object value);
<Value_> Value_ removeStore(int index);
}
|
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/TupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common;
public interface TupleLifecycle<Tuple_ extends Tuple> {
static <Tuple_ extends Tuple> TupleLifecycle<Tuple_> ofLeft(LeftTupleLifecycle<Tuple_> leftTupleLifecycle) {
return new LeftTupleLifecycleImpl<>(leftTupleLifecycle);
}
static <Tuple_ extends Tuple> TupleLifecycle<Tuple_> ofRight(RightTupleLifecycle<Tuple_> rightTupleLifecycle) {
return new RightTupleLifecycleImpl<>(rightTupleLifecycle);
}
void insert(Tuple_ tuple);
void update(Tuple_ tuple);
void retract(Tuple_ tuple);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/collection/TupleList.java | package ai.timefold.solver.constraint.streams.bavet.common.collection;
import java.util.LinkedList;
import java.util.List;
import java.util.function.Consumer;
/**
* Different from {@link LinkedList} because nodes/indexes are allowed
* to directly reference {@link TupleListEntry} instances
* to avoid the lookup by index cost.
* Also doesn't implement the {@link List} interface.
*
* @param <T> The element type. Often a tuple.
*/
public final class TupleList<T> {
private int size = 0;
private TupleListEntry<T> first = null;
private TupleListEntry<T> last = null;
public TupleListEntry<T> add(T tuple) {
TupleListEntry<T> entry = new TupleListEntry<>(this, tuple, last);
if (first == null) {
first = entry;
} else {
last.next = entry;
}
last = entry;
size++;
return entry;
}
public void remove(TupleListEntry<T> entry) {
if (first == entry) {
first = entry.next;
} else {
entry.previous.next = entry.next;
}
if (last == entry) {
last = entry.previous;
} else {
entry.next.previous = entry.previous;
}
entry.previous = null;
entry.next = null;
size--;
}
public TupleListEntry<T> first() {
return first;
}
public TupleListEntry<T> last() {
return last;
}
public int size() {
return size;
}
public void forEach(Consumer<T> tupleConsumer) {
TupleListEntry<T> entry = first;
while (entry != null) {
// Extract next before processing it, in case the entry is removed and entry.next becomes null
TupleListEntry<T> next = entry.next;
tupleConsumer.accept(entry.getElement());
entry = next;
}
}
@Override
public String toString() {
return "size = " + size;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/collection/TupleListEntry.java | package ai.timefold.solver.constraint.streams.bavet.common.collection;
/**
* An entry of {@link TupleList}
*
* @param <T> The element type. Often a tuple.
*/
public final class TupleListEntry<T> {
private TupleList<T> list;
private final T element;
TupleListEntry<T> previous;
TupleListEntry<T> next;
TupleListEntry(TupleList<T> list, T element, TupleListEntry<T> previous) {
this.list = list;
this.element = element;
this.previous = previous;
this.next = null;
}
public TupleListEntry<T> next() {
return next;
}
public TupleListEntry<T> removeAndNext() {
TupleListEntry<T> next = this.next;
remove(); // Sets this.next = null
return next;
}
public void remove() {
if (list == null) {
throw new IllegalStateException("The element (" + element + ") was already removed.");
}
list.remove(this);
list = null;
}
public T getElement() {
return element;
}
public TupleList<T> getList() {
return list;
}
@Override
public String toString() {
return element.toString();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/ComparisonIndexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Comparator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Objects;
import java.util.TreeMap;
import java.util.function.Consumer;
import java.util.function.Supplier;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleListEntry;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
final class ComparisonIndexer<T, Key_ extends Comparable<Key_>> implements Indexer<T> {
private final int indexKeyPosition;
private final Supplier<Indexer<T>> downstreamIndexerSupplier;
private final Comparator<Key_> keyComparator;
private final boolean hasOrEquals;
private final NavigableMap<Key_, Indexer<T>> comparisonMap;
public ComparisonIndexer(JoinerType comparisonJoinerType, Supplier<Indexer<T>> downstreamIndexerSupplier) {
this(comparisonJoinerType, 0, downstreamIndexerSupplier);
}
public ComparisonIndexer(JoinerType comparisonJoinerType, int indexKeyPosition,
Supplier<Indexer<T>> downstreamIndexerSupplier) {
this.indexKeyPosition = indexKeyPosition;
this.downstreamIndexerSupplier = Objects.requireNonNull(downstreamIndexerSupplier);
/*
* For GT/GTE, the iteration order is reversed.
* This allows us to iterate over the entire map, stopping when the threshold is reached.
* This is done so that we can avoid using head/tail sub maps, which are expensive.
*/
this.keyComparator =
(comparisonJoinerType == JoinerType.GREATER_THAN || comparisonJoinerType == JoinerType.GREATER_THAN_OR_EQUAL)
? KeyComparator.INSTANCE.reversed()
: KeyComparator.INSTANCE;
this.hasOrEquals = comparisonJoinerType == JoinerType.GREATER_THAN_OR_EQUAL
|| comparisonJoinerType == JoinerType.LESS_THAN_OR_EQUAL;
this.comparisonMap = new TreeMap<>(keyComparator);
}
@Override
public TupleListEntry<T> put(IndexProperties indexProperties, T tuple) {
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
Indexer<T> downstreamIndexer = comparisonMap.get(indexKey);
if (downstreamIndexer == null) {
downstreamIndexer = downstreamIndexerSupplier.get();
comparisonMap.put(indexKey, downstreamIndexer);
}
return downstreamIndexer.put(indexProperties, tuple);
}
@Override
public void remove(IndexProperties indexProperties, TupleListEntry<T> entry) {
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
Indexer<T> downstreamIndexer = getDownstreamIndexer(indexProperties, indexKey, entry);
downstreamIndexer.remove(indexProperties, entry);
if (downstreamIndexer.isEmpty()) {
comparisonMap.remove(indexKey);
}
}
private Indexer<T> getDownstreamIndexer(IndexProperties indexProperties, Key_ indexerKey,
TupleListEntry<T> entry) {
Indexer<T> downstreamIndexer = comparisonMap.get(indexerKey);
if (downstreamIndexer == null) {
throw new IllegalStateException("Impossible state: the tuple (" + entry.getElement()
+ ") with indexProperties (" + indexProperties
+ ") doesn't exist in the indexer " + this + ".");
}
return downstreamIndexer;
}
// TODO clean up DRY
@Override
public int size(IndexProperties indexProperties) {
int mapSize = comparisonMap.size();
if (mapSize == 0) {
return 0;
}
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
if (mapSize == 1) { // Avoid creation of the entry set and iterator.
Map.Entry<Key_, Indexer<T>> entry = comparisonMap.firstEntry();
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
return 0;
}
}
return entry.getValue().size(indexProperties);
} else {
int size = 0;
for (Map.Entry<Key_, Indexer<T>> entry : comparisonMap.entrySet()) {
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
break;
}
}
// Boundary condition not yet reached; include the indexer in the range.
size += entry.getValue().size(indexProperties);
}
return size;
}
}
@Override
public void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer) {
int size = comparisonMap.size();
if (size == 0) {
return;
}
Key_ indexKey = indexProperties.toKey(indexKeyPosition);
if (size == 1) { // Avoid creation of the entry set and iterator.
Map.Entry<Key_, Indexer<T>> entry = comparisonMap.firstEntry();
visitEntry(indexProperties, tupleConsumer, indexKey, entry);
} else {
for (Map.Entry<Key_, Indexer<T>> entry : comparisonMap.entrySet()) {
boolean boundaryReached = visitEntry(indexProperties, tupleConsumer, indexKey, entry);
if (boundaryReached) {
return;
}
}
}
}
private boolean visitEntry(IndexProperties indexProperties, Consumer<T> tupleConsumer,
Key_ indexKey, Map.Entry<Key_, Indexer<T>> entry) {
// Comparator matches the order of iteration of the map, so the boundary is always found from the bottom up.
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
return true;
}
}
// Boundary condition not yet reached; include the indexer in the range.
entry.getValue().forEach(indexProperties, tupleConsumer);
return false;
}
@Override
public boolean isEmpty() {
return comparisonMap.isEmpty();
}
@Override
public String toString() {
return "size = " + comparisonMap.size();
}
private static final class KeyComparator<Key_ extends Comparable<Key_>> implements Comparator<Key_> {
private static final Comparator INSTANCE = new KeyComparator<>();
@Override
public int compare(Key_ o1, Key_ o2) {
if (o1 == o2) {
return 0;
}
return o1.compareTo(o2);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/EqualsIndexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Supplier;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleListEntry;
final class EqualsIndexer<T, Key_> implements Indexer<T> {
private final int indexKeyFrom;
private final int indexKeyTo;
private final Supplier<Indexer<T>> downstreamIndexerSupplier;
private final Map<Key_, Indexer<T>> downstreamIndexerMap = new HashMap<>();
public EqualsIndexer(Supplier<Indexer<T>> downstreamIndexerSupplier) {
this(0, 1, downstreamIndexerSupplier);
}
public EqualsIndexer(int indexKeyFromInclusive, int indexKeyToExclusive,
Supplier<Indexer<T>> downstreamIndexerSupplier) {
this.indexKeyFrom = indexKeyFromInclusive;
this.indexKeyTo = indexKeyToExclusive;
this.downstreamIndexerSupplier = Objects.requireNonNull(downstreamIndexerSupplier);
}
@Override
public TupleListEntry<T> put(IndexProperties indexProperties, T tuple) {
Key_ indexKey = indexProperties.toKey(indexKeyFrom, indexKeyTo);
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null) {
downstreamIndexer = downstreamIndexerSupplier.get();
downstreamIndexerMap.put(indexKey, downstreamIndexer);
}
return downstreamIndexer.put(indexProperties, tuple);
}
@Override
public void remove(IndexProperties indexProperties, TupleListEntry<T> entry) {
Key_ indexKey = indexProperties.toKey(indexKeyFrom, indexKeyTo);
Indexer<T> downstreamIndexer = getDownstreamIndexer(indexProperties, indexKey, entry);
downstreamIndexer.remove(indexProperties, entry);
if (downstreamIndexer.isEmpty()) {
downstreamIndexerMap.remove(indexKey);
}
}
private Indexer<T> getDownstreamIndexer(IndexProperties indexProperties, Key_ indexerKey,
TupleListEntry<T> entry) {
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexerKey);
if (downstreamIndexer == null) {
throw new IllegalStateException("Impossible state: the tuple (" + entry.getElement()
+ ") with indexProperties (" + indexProperties
+ ") doesn't exist in the indexer " + this + ".");
}
return downstreamIndexer;
}
@Override
public int size(IndexProperties indexProperties) {
Key_ indexKey = indexProperties.toKey(indexKeyFrom, indexKeyTo);
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null) {
return 0;
}
return downstreamIndexer.size(indexProperties);
}
@Override
public void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer) {
Key_ indexKey = indexProperties.toKey(indexKeyFrom, indexKeyTo);
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null || downstreamIndexer.isEmpty()) {
return;
}
downstreamIndexer.forEach(indexProperties, tupleConsumer);
}
@Override
public boolean isEmpty() {
return downstreamIndexerMap.isEmpty();
}
@Override
public String toString() {
return "size = " + downstreamIndexerMap.size();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/IndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
/**
* Index properties are cached in tuples and each tuple carries its unique instance.
* <p>
* Index properties are shallow immutable and implement {@link Object#equals(Object)} and {@link Object#hashCode()}.
*/
public interface IndexProperties {
/**
* Retrieves index property at a given position.
*
* @param index
* @return never null
* @param <Type_> {@link ComparisonIndexer} will expect this to implement {@link Comparable}.
*/
<Type_> Type_ toKey(int index);
/**
* Retrieves an object to serve as a key in an index.
* Instances retrieved using the same arguments must be {@link Object#equals(Object) equal}.
*
* @param <Type_> expected type of the key
* @param from index of the first property to use, inclusive
* @param to index of the last property to use, exclusive
* @return never null
*/
<Type_> Type_ toKey(int from, int to);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/Indexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.function.Consumer;
import ai.timefold.solver.constraint.streams.bavet.common.BavetTupleState;
import ai.timefold.solver.constraint.streams.bavet.common.collection.TupleListEntry;
/**
* An indexer for entity or fact {@code X},
* maps a property or a combination of properties of {@code X}, denoted by {@code indexProperties},
* to all instances of {@code X} that match those properties,
* depending on the the indexer type (equal, lower than, ...).
* For example for {@code {Lesson(id=1, room=A), Lesson(id=2, room=B), Lesson(id=3, room=A)}},
* calling {@code visit(room=A)} would visit lesson 1 and 3.
* <p>
* The fact X is wrapped in a Tuple, because the {@link BavetTupleState} is needed by clients of
* {@link #forEach(IndexProperties, Consumer)}.
*
* @param <T> The element type. Often a tuple.
* For example for {@code from(A).join(B)}, the tuple is {@code UniTuple<A>} xor {@code UniTuple<B>}.
* For example for {@code Bi<A, B>.join(C)}, the tuple is {@code BiTuple<A, B>} xor {@code UniTuple<C>}.
*/
public interface Indexer<T> {
TupleListEntry<T> put(IndexProperties indexProperties, T tuple);
void remove(IndexProperties indexProperties, TupleListEntry<T> entry);
int size(IndexProperties indexProperties);
void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer);
boolean isEmpty();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/IndexerFactory.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Map;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.function.Supplier;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public class IndexerFactory {
private final JoinerType[] joinerTypes;
public IndexerFactory(AbstractJoiner joiner) {
int joinerCount = joiner.getJoinerCount();
joinerTypes = new JoinerType[joinerCount];
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = joiner.getJoinerType(i);
switch (joinerType) {
case EQUAL:
case LESS_THAN:
case LESS_THAN_OR_EQUAL:
case GREATER_THAN:
case GREATER_THAN_OR_EQUAL:
break;
default:
throw new UnsupportedOperationException("Unsupported joiner type (" + joinerType + ").");
}
joinerTypes[i] = joiner.getJoinerType(i);
}
}
public boolean hasJoiners() {
return joinerTypes.length > 0;
}
public <T> Indexer<T> buildIndexer(boolean isLeftBridge) {
/*
* Indexers form a parent-child hierarchy, each child has exactly one parent.
* NoneIndexer is always at the bottom of the hierarchy, never a parent unless it is the only indexer.
* Parent indexers delegate to their children, until they reach the ultimate NoneIndexer.
* Example 1: EQUAL+LESS_THAN joiner will become EqualsIndexer -> ComparisonIndexer -> NoneIndexer.
*
* Note that if creating indexer for a right bridge node, the joiner type has to be flipped.
* (<A, B> becomes <B, A>.)
*/
if (joinerTypes.length == 0) { // NoneJoiner results in NoneIndexer.
return new NoneIndexer<>();
} else if (joinerTypes.length == 1) { // Single joiner maps directly to EqualsIndexer or ComparisonIndexer.
JoinerType joinerType = joinerTypes[0];
if (joinerType == JoinerType.EQUAL) {
return new EqualsIndexer<>(NoneIndexer::new);
} else {
return new ComparisonIndexer<>(isLeftBridge ? joinerType : joinerType.flip(), NoneIndexer::new);
}
}
/*
* For more than 1 joiner, we need to build the actual hierarchy. The following rules apply:
*
* Rule 1: Two or more consecutive EQUAL joiners become a single EqualsIndexer.
* Example: EQUAL+EQUAL+LESS_THAN results in EqualsIndexer -> ComparisonIndexer.
*
* Rule 2: Once a joiner type in the sequence changes (from EQUALS to comparison or vice versa),
* the joiner on the right results in an indexer that is a child to the indexer of the joiner on the left.
* Example: EQUAL+LESS_THAN+EQUAL results in EqualsIndexer -> ComparisonIndexer -> EqualsIndexer.
*
* The following code builds the children first, so it needs to iterate over the joiners in reverse order.
*/
NavigableMap<Integer, JoinerType> joinerTypeMap = new TreeMap<>();
for (int i = 1; i <= joinerTypes.length; i++) {
JoinerType joinerType = i < joinerTypes.length ? joinerTypes[i] : null;
JoinerType previousJoinerType = joinerTypes[i - 1];
if (joinerType != JoinerType.EQUAL || previousJoinerType != joinerType) {
joinerTypeMap.put(i, previousJoinerType);
}
}
NavigableMap<Integer, JoinerType> descendingJoinerTypeMap = joinerTypeMap.descendingMap();
Supplier<Indexer<T>> downstreamIndexerSupplier = NoneIndexer::new;
for (Map.Entry<Integer, JoinerType> entry : descendingJoinerTypeMap.entrySet()) {
Integer endingPropertyExclusive = entry.getKey();
Integer previousEndingPropertyExclusiveOrNull = descendingJoinerTypeMap.higherKey(endingPropertyExclusive);
int previousEndingPropertyExclusive =
previousEndingPropertyExclusiveOrNull == null ? 0 : previousEndingPropertyExclusiveOrNull;
JoinerType joinerType = entry.getValue();
Supplier<Indexer<T>> actualDownstreamIndexerSupplier = downstreamIndexerSupplier;
if (joinerType == JoinerType.EQUAL) {
/*
* Equals indexer keys may span multiple index properties, one for each EQUALS joiner.
*
* Example 1: For an EQUAL+LESS_THAN joiner, indexer key is of length 1 and starts at position 0.
* Example 2: For an LESS_THAN+EQUAL+EQUAL joiner, indexer key is of length 2 and starts at position 1.
*/
if (endingPropertyExclusive <= previousEndingPropertyExclusive) {
throw new IllegalStateException("Impossible state: index key ending position <= starting position ("
+ endingPropertyExclusive + " <= " + previousEndingPropertyExclusive + ")");
}
downstreamIndexerSupplier = () -> new EqualsIndexer<>(previousEndingPropertyExclusive, endingPropertyExclusive,
actualDownstreamIndexerSupplier);
} else {
JoinerType actualJoinerType = isLeftBridge ? joinerType : joinerType.flip();
/*
* Comparison indexers only ever have one comparison key.
* Its position is the next one immediately following the preceding EQUALS position,
* or the first one if there are no preceding EQUALS joiners.
*
* Example 1: For an EQUAL+LESS_THAN joiner, comparison key is on position 1.
* Example 2: For an EQUAL+EQUAL+LESS_THAN joiner: comparison key is on position 2.
*/
downstreamIndexerSupplier = () -> new ComparisonIndexer<>(actualJoinerType, previousEndingPropertyExclusive,
actualDownstreamIndexerSupplier);
}
}
return downstreamIndexerSupplier.get();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/IndexerKey.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Objects;
import java.util.stream.Collectors;
import java.util.stream.IntStream;
import ai.timefold.solver.core.impl.util.Pair;
import ai.timefold.solver.core.impl.util.Triple;
/**
* Often replaced by a specialization such as {@link Pair}, {@link Triple}, ...
*/
final class IndexerKey {
private final IndexProperties indexProperties;
private final int fromInclusive;
private final int toExclusive;
public IndexerKey(IndexProperties indexProperties, int fromInclusive, int toExclusive) {
this.indexProperties = indexProperties;
this.fromInclusive = fromInclusive;
this.toExclusive = toExclusive;
}
@Override
public int hashCode() {
if (indexProperties == null) {
return 0;
}
int result = 1;
for (int i = fromInclusive; i < toExclusive; i++) {
Object element = indexProperties.toKey(i);
result = 31 * result + (element == null ? 0 : element.hashCode());
}
return result;
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (!(o instanceof IndexerKey)) {
return false;
}
IndexerKey other = (IndexerKey) o;
for (int i = fromInclusive; i < toExclusive; i++) {
Object a = indexProperties.toKey(i);
Object b = other.indexProperties.toKey(i);
if (!Objects.equals(a, b)) {
return false;
}
}
return true;
}
@Override
public String toString() {
return "IndexerKey " + IntStream.range(fromInclusive, toExclusive)
.mapToObj(indexProperties::toKey)
.map(Object::toString)
.collect(Collectors.joining(",", "[", "]"));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/JoinerUtils.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.constraint.streams.common.bi.DefaultBiJoiner;
import ai.timefold.solver.constraint.streams.common.penta.DefaultPentaJoiner;
import ai.timefold.solver.constraint.streams.common.quad.DefaultQuadJoiner;
import ai.timefold.solver.constraint.streams.common.tri.DefaultTriJoiner;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
public final class JoinerUtils {
private JoinerUtils() {
}
public static <A, B> Function<A, IndexProperties> combineLeftMappings(DefaultBiJoiner<A, B> joiner) {
int joinerCount = joiner.getJoinerCount();
switch (joinerCount) {
case 0:
return (A a) -> NoneIndexProperties.INSTANCE;
case 1:
Function<A, Object> mapping = joiner.getLeftMapping(0);
return (A a) -> new SingleIndexProperties(mapping.apply(a));
case 2:
Function<A, Object> mappingX = joiner.getLeftMapping(0);
Function<A, Object> mappingY = joiner.getLeftMapping(1);
return (A a) -> new TwoIndexProperties(mappingX.apply(a), mappingY.apply(a));
case 3:
Function<A, Object> mapping1 = joiner.getLeftMapping(0);
Function<A, Object> mapping2 = joiner.getLeftMapping(1);
Function<A, Object> mapping3 = joiner.getLeftMapping(2);
return (A a) -> new ThreeIndexProperties(mapping1.apply(a), mapping2.apply(a), mapping3.apply(a));
default:
return (A a) -> {
Object[] mappings = new Object[joinerCount];
for (int i = 0; i < joinerCount; i++) {
mappings[i] = joiner.getLeftMapping(i).apply(a);
}
return new ManyIndexProperties(mappings);
};
}
}
public static <A, B, C> BiFunction<A, B, IndexProperties> combineLeftMappings(DefaultTriJoiner<A, B, C> joiner) {
int joinerCount = joiner.getJoinerCount();
switch (joinerCount) {
case 0:
return (A a, B b) -> NoneIndexProperties.INSTANCE;
case 1:
BiFunction<A, B, Object> mapping = joiner.getLeftMapping(0);
return (A a, B b) -> new SingleIndexProperties(mapping.apply(a, b));
case 2:
BiFunction<A, B, Object> mappingX = joiner.getLeftMapping(0);
BiFunction<A, B, Object> mappingY = joiner.getLeftMapping(1);
return (A a, B b) -> new TwoIndexProperties(mappingX.apply(a, b), mappingY.apply(a, b));
case 3:
BiFunction<A, B, Object> mapping1 = joiner.getLeftMapping(0);
BiFunction<A, B, Object> mapping2 = joiner.getLeftMapping(1);
BiFunction<A, B, Object> mapping3 = joiner.getLeftMapping(2);
return (A a, B b) -> new ThreeIndexProperties(mapping1.apply(a, b), mapping2.apply(a, b),
mapping3.apply(a, b));
default:
return (A a, B b) -> {
Object[] mappings = new Object[joinerCount];
for (int i = 0; i < joinerCount; i++) {
mappings[i] = joiner.getLeftMapping(i).apply(a, b);
}
return new ManyIndexProperties(mappings);
};
}
}
public static <A, B, C, D> TriFunction<A, B, C, IndexProperties> combineLeftMappings(DefaultQuadJoiner<A, B, C, D> joiner) {
int joinerCount = joiner.getJoinerCount();
switch (joinerCount) {
case 0:
return (A a, B b, C c) -> NoneIndexProperties.INSTANCE;
case 1:
TriFunction<A, B, C, Object> mapping = joiner.getLeftMapping(0);
return (A a, B b, C c) -> new SingleIndexProperties(mapping.apply(a, b, c));
case 2:
TriFunction<A, B, C, Object> mappingX = joiner.getLeftMapping(0);
TriFunction<A, B, C, Object> mappingY = joiner.getLeftMapping(1);
return (A a, B b, C c) -> new TwoIndexProperties(mappingX.apply(a, b, c), mappingY.apply(a, b, c));
case 3:
TriFunction<A, B, C, Object> mapping1 = joiner.getLeftMapping(0);
TriFunction<A, B, C, Object> mapping2 = joiner.getLeftMapping(1);
TriFunction<A, B, C, Object> mapping3 = joiner.getLeftMapping(2);
return (A a, B b, C c) -> new ThreeIndexProperties(mapping1.apply(a, b, c), mapping2.apply(a, b, c),
mapping3.apply(a, b, c));
default:
return (A a, B b, C c) -> {
Object[] mappings = new Object[joinerCount];
for (int i = 0; i < joinerCount; i++) {
mappings[i] = joiner.getLeftMapping(i).apply(a, b, c);
}
return new ManyIndexProperties(mappings);
};
}
}
public static <A, B, C, D, E> QuadFunction<A, B, C, D, IndexProperties> combineLeftMappings(
DefaultPentaJoiner<A, B, C, D, E> joiner) {
int joinerCount = joiner.getJoinerCount();
switch (joinerCount) {
case 0:
return (A a, B b, C c, D d) -> NoneIndexProperties.INSTANCE;
case 1:
QuadFunction<A, B, C, D, Object> mapping = joiner.getLeftMapping(0);
return (A a, B b, C c, D d) -> new SingleIndexProperties(mapping.apply(a, b, c, d));
case 2:
QuadFunction<A, B, C, D, Object> mappingX = joiner.getLeftMapping(0);
QuadFunction<A, B, C, D, Object> mappingY = joiner.getLeftMapping(1);
return (A a, B b, C c, D d) -> new TwoIndexProperties(mappingX.apply(a, b, c, d),
mappingY.apply(a, b, c, d));
case 3:
QuadFunction<A, B, C, D, Object> mapping1 = joiner.getLeftMapping(0);
QuadFunction<A, B, C, D, Object> mapping2 = joiner.getLeftMapping(1);
QuadFunction<A, B, C, D, Object> mapping3 = joiner.getLeftMapping(2);
return (A a, B b, C c, D d) -> new ThreeIndexProperties(mapping1.apply(a, b, c, d),
mapping2.apply(a, b, c, d), mapping3.apply(a, b, c, d));
default:
return (A a, B b, C c, D d) -> {
Object[] mappings = new Object[joinerCount];
for (int i = 0; i < joinerCount; i++) {
mappings[i] = joiner.getLeftMapping(i).apply(a, b, c, d);
}
return new ManyIndexProperties(mappings);
};
}
}
public static <Right_> Function<Right_, IndexProperties> combineRightMappings(AbstractJoiner<Right_> joiner) {
int joinerCount = joiner.getJoinerCount();
switch (joinerCount) {
case 0:
return (Right_ right) -> NoneIndexProperties.INSTANCE;
case 1:
Function<Right_, Object> mapping = joiner.getRightMapping(0);
return (Right_ right) -> new SingleIndexProperties(mapping.apply(right));
case 2:
Function<Right_, Object> mappingX = joiner.getRightMapping(0);
Function<Right_, Object> mappingY = joiner.getRightMapping(1);
return (Right_ right) -> new TwoIndexProperties(mappingX.apply(right), mappingY.apply(right));
case 3:
Function<Right_, Object> mapping1 = joiner.getRightMapping(0);
Function<Right_, Object> mapping2 = joiner.getRightMapping(1);
Function<Right_, Object> mapping3 = joiner.getRightMapping(2);
return (Right_ right) -> new ThreeIndexProperties(mapping1.apply(right), mapping2.apply(right),
mapping3.apply(right));
default:
return (Right_ right) -> {
Object[] mappings = new Object[joinerCount];
for (int i = 0; i < joinerCount; i++) {
mappings[i] = joiner.getRightMapping(i).apply(right);
}
return new ManyIndexProperties(mappings);
};
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/ManyIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Arrays;
import ai.timefold.solver.core.impl.util.Pair;
import ai.timefold.solver.core.impl.util.Quadruple;
import ai.timefold.solver.core.impl.util.Triple;
final class ManyIndexProperties implements IndexProperties {
private final Object[] properties;
ManyIndexProperties(Object... properties) {
this.properties = properties;
}
@Override
public <Type_> Type_ toKey(int index) {
return (Type_) properties[index];
}
@Override
public <Type_> Type_ toKey(int from, int to) {
switch (to - from) {
case 1:
return toKey(from);
case 2:
return (Type_) Pair.of(toKey(from), toKey(from + 1));
case 3:
return (Type_) Triple.of(toKey(from), toKey(from + 1),
toKey(from + 2));
case 4:
return (Type_) Quadruple.of(toKey(from), toKey(from + 1),
toKey(from + 2), toKey(from + 3));
default:
return (Type_) new IndexerKey(this, from, to);
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof ManyIndexProperties)) {
return false;
}
ManyIndexProperties other = (ManyIndexProperties) o;
return Arrays.equals(properties, other.properties);
}
@Override
public int hashCode() {
return Arrays.hashCode(properties);
}
@Override
public String toString() {
return Arrays.toString(properties);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/NoneIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
final class NoneIndexProperties implements IndexProperties {
static final NoneIndexProperties INSTANCE = new NoneIndexProperties();
private NoneIndexProperties() {
}
@Override
public <Type_> Type_ toKey(int index) {
throw new IllegalArgumentException("Impossible state: none index property requested");
}
@Override
public <Type_> Type_ toKey(int from, int to) {
throw new IllegalArgumentException("Impossible state: none index property requested");
}
@Override
public String toString() {
return "[]";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/NoneIndexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
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;
final class NoneIndexer<T, Value_> implements Indexer<T> {
private final TupleList<T> tupleList = new TupleList<>();
@Override
public TupleListEntry<T> put(IndexProperties indexProperties, T tuple) {
return tupleList.add(tuple);
}
@Override
public void remove(IndexProperties indexProperties, TupleListEntry<T> entry) {
entry.remove();
}
@Override
public int size(IndexProperties indexProperties) {
return tupleList.size();
}
@Override
public void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer) {
tupleList.forEach(tupleConsumer);
}
@Override
public boolean isEmpty() {
return tupleList.size() == 0;
}
@Override
public String toString() {
return "size = " + tupleList.size();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/SingleIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Objects;
final class SingleIndexProperties implements IndexProperties {
private final Object property;
SingleIndexProperties(Object property) {
this.property = property;
}
@Override
public <Type_> Type_ toKey(int index) {
if (index != 0) {
throw new IllegalArgumentException("Impossible state: index (" + index + ") != 0");
}
return (Type_) property;
}
@Override
public <Type_> Type_ toKey(int from, int to) {
if (to != 1) {
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
return toKey(from);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof SingleIndexProperties)) {
return false;
}
SingleIndexProperties other = (SingleIndexProperties) o;
return Objects.equals(property, other.property);
}
@Override
public int hashCode() { // Not using Objects.hash(Object...) as that would create an array on the hot path.
return Objects.hashCode(property);
}
@Override
public String toString() {
return "[" + property + "]";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/ThreeIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Objects;
import ai.timefold.solver.core.impl.util.Pair;
final class ThreeIndexProperties implements IndexProperties {
private final Object propertyA;
private final Object propertyB;
private final Object propertyC;
ThreeIndexProperties(Object propertyA, Object propertyB, Object propertyC) {
this.propertyA = propertyA;
this.propertyB = propertyB;
this.propertyC = propertyC;
}
@Override
public <Type_> Type_ toKey(int index) {
switch (index) {
case 0:
return (Type_) propertyA;
case 1:
return (Type_) propertyB;
case 2:
return (Type_) propertyC;
default:
throw new IllegalArgumentException("Impossible state: index (" + index + ") != 0");
}
}
@Override
public <Type_> Type_ toKey(int from, int to) {
switch (to - from) {
case 1:
return toKey(from);
case 2:
return (Type_) Pair.of(toKey(from), toKey(from + 1));
case 3:
if (from != 0 || to != 3) {
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
return (Type_) this;
default:
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof ThreeIndexProperties)) {
return false;
}
ThreeIndexProperties other = (ThreeIndexProperties) o;
return Objects.equals(propertyA, other.propertyA)
&& Objects.equals(propertyB, other.propertyB)
&& Objects.equals(propertyC, other.propertyC);
}
@Override
public int hashCode() { // Not using Objects.hash(Object...) as that would create an array on the hot path.
int result = Objects.hashCode(propertyA);
result = 31 * result + Objects.hashCode(propertyB);
result = 31 * result + Objects.hashCode(propertyC);
return result;
}
@Override
public String toString() {
return "[" + propertyA + ", " + propertyB + ", " + propertyC + "]";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/common/index/TwoIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Objects;
final class TwoIndexProperties implements IndexProperties {
private final Object propertyA;
private final Object propertyB;
TwoIndexProperties(Object propertyA, Object propertyB) {
this.propertyA = propertyA;
this.propertyB = propertyB;
}
@Override
public <Type_> Type_ toKey(int index) {
switch (index) {
case 0:
return (Type_) propertyA;
case 1:
return (Type_) propertyB;
default:
throw new IllegalArgumentException("Impossible state: index (" + index + ") != 0");
}
}
@Override
public <Type_> Type_ toKey(int from, int to) {
switch (to - from) {
case 1:
return toKey(from);
case 2:
if (from != 0 || to != 2) {
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
return (Type_) this;
default:
throw new IllegalArgumentException("Impossible state: key from (" + from + ") to (" + to + ").");
}
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof TwoIndexProperties)) {
return false;
}
TwoIndexProperties other = (TwoIndexProperties) o;
return Objects.equals(propertyA, other.propertyA)
&& Objects.equals(propertyB, other.propertyB);
}
@Override
public int hashCode() { // Not using Objects.hash(Object...) as that would create an array on the hot path.
int result = Objects.hashCode(propertyA);
result = 31 * result + Objects.hashCode(propertyB);
return result;
}
@Override
public String toString() {
return "[" + propertyA + ", " + propertyB + "]";
}
}
|
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/quad/AbstractGroupQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.PentaFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
abstract class AbstractGroupQuadNode<OldA, OldB, OldC, OldD, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_, GroupKey_, ResultContainer_, Result_>
extends
AbstractGroupNode<QuadTuple<OldA, OldB, OldC, OldD>, OutTuple_, MutableOutTuple_, GroupKey_, ResultContainer_, Result_> {
private final PentaFunction<ResultContainer_, OldA, OldB, OldC, OldD, Runnable> accumulator;
protected AbstractGroupQuadNode(int groupStoreIndex, int undoStoreIndex,
Function<QuadTuple<OldA, OldB, OldC, OldD>, GroupKey_> groupKeyFunction,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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 AbstractGroupQuadNode(int groupStoreIndex,
Function<QuadTuple<OldA, OldB, OldC, OldD>, GroupKey_> groupKeyFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
super(groupStoreIndex, groupKeyFunction, nextNodesTupleLifecycle, environmentMode);
accumulator = null;
}
@Override
protected final Runnable accumulate(ResultContainer_ resultContainer, QuadTuple<OldA, OldB, OldC, OldD> tuple) {
return accumulator.apply(resultContainer, tuple.getFactA(), tuple.getFactB(), tuple.getFactC(), tuple.getFactD());
}
}
|
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/quad/BavetAbstractQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetGroupBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
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.tri.BavetGroupTriConstraintStream;
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.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.penta.PentaJoinerComber;
import ai.timefold.solver.constraint.streams.common.quad.InnerQuadConstraintStream;
import ai.timefold.solver.constraint.streams.common.quad.QuadConstraintBuilderImpl;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
public abstract class BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractConstraintStream<Solution_>
implements InnerQuadConstraintStream<A, B, C, D> {
protected final List<BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>> childStreamList = new ArrayList<>(2);
public BavetAbstractQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
public List<BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>> getChildStreamList() {
return childStreamList;
}
// ************************************************************************
// Stream builder methods
// ************************************************************************
public <Stream_ extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>> Stream_ shareAndAddChild(
Stream_ stream) {
return constraintFactory.share(stream, childStreamList::add);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> filter(QuadPredicate<A, B, C, D> predicate) {
return shareAndAddChild(
new BavetFilterQuadConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final <E> QuadConstraintStream<A, B, C, D> ifExists(Class<E> otherClass, PentaJoiner<A, B, C, D, E>... 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 <E> QuadConstraintStream<A, B, C, D> ifExistsIncludingNullVars(Class<E> otherClass,
PentaJoiner<A, B, C, D, E>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEachIncludingNullVars(otherClass), joiners);
} else {
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <E> QuadConstraintStream<A, B, C, D> ifExists(UniConstraintStream<E> otherStream,
PentaJoiner<A, B, C, D, E>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final <E> QuadConstraintStream<A, B, C, D> ifNotExists(Class<E> otherClass, PentaJoiner<A, B, C, D, E>... 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 <E> QuadConstraintStream<A, B, C, D> ifNotExistsIncludingNullVars(Class<E> otherClass,
PentaJoiner<A, B, C, D, E>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEachIncludingNullVars(otherClass), joiners);
} else {
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <E> QuadConstraintStream<A, B, C, D> ifNotExists(UniConstraintStream<E> otherStream,
PentaJoiner<A, B, C, D, E>... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <E> QuadConstraintStream<A, B, C, D> ifExistsOrNot(boolean shouldExist,
UniConstraintStream<E> otherStream, PentaJoiner<A, B, C, D, E>[] joiners) {
BavetAbstractUniConstraintStream<Solution_, E> other = assertBavetUniConstraintStream(otherStream);
PentaJoinerComber<A, B, C, D, E> joinerComber = PentaJoinerComber.comb(joiners);
BavetIfExistsBridgeUniConstraintStream<Solution_, E> parentBridgeD = other.shareAndAddChild(
new BavetIfExistsBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsQuadConstraintStream<>(constraintFactory, this, parentBridgeD,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group0Mapping1CollectorQuadNode<>(groupStoreIndex, undoStoreIndex,
collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
BavetUniGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA> bridge = shareAndAddChild(
new BavetUniGroupBridgeQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupUniConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group0Mapping2CollectorQuadNode<>(groupStoreIndex, undoStoreIndex,
collectorA, collectorB, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
BavetBiGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB> bridge = shareAndAddChild(
new BavetBiGroupBridgeQuadConstraintStream<>(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(QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex,
tupleLifecycle, outputStoreSize, environmentMode) -> new Group0Mapping3CollectorQuadNode<>(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) {
BavetTriGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC> bridge = shareAndAddChild(
new BavetTriGroupBridgeQuadConstraintStream<>(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(QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group0Mapping4CollectorQuadNode<>(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) {
BavetQuadGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC, NewD> bridge = shareAndAddChild(
new BavetQuadGroupBridgeQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupQuadConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group1Mapping0CollectorQuadNode<>(
groupKeyMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_> groupBy(QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping2CollectorQuadNode<>(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(QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping3CollectorQuadNode<>(groupKeyMapping, groupStoreIndex, undoStoreIndex,
collectorB, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group1Mapping1CollectorQuadNode<>(groupKeyMapping, groupStoreIndex,
undoStoreIndex, collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group2Mapping0CollectorQuadNode<>(
groupKeyAMapping, groupKeyBMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_> groupBy(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping1CollectorQuadNode<>(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(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping2CollectorQuadNode<>(groupKeyAMapping, groupKeyBMapping, groupStoreIndex,
undoStoreIndex, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping, QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor = of((groupStoreIndex,
tupleLifecycle, outputStoreSize, environmentMode) -> new Group3Mapping0CollectorQuadNode<>(groupKeyAMapping,
groupKeyBMapping, groupKeyCMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group3Mapping1CollectorQuadNode<>(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping,
groupStoreIndex, undoStoreIndex, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping,
QuadFunction<A, B, C, D, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group4Mapping0CollectorQuadNode<>(
groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping, groupStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public <ResultA_> UniConstraintStream<ResultA_> map(QuadFunction<A, B, C, D, ResultA_> mapping) {
BavetMapBridgeQuadConstraintStream<Solution_, A, B, C, D, ResultA_> bridge = shareAndAddChild(
new BavetMapBridgeQuadConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetMapUniConstraintStream<>(constraintFactory, bridge),
bridge::setMapStream);
}
@Override
public <ResultD_> QuadConstraintStream<A, B, C, ResultD_> flattenLast(Function<D, Iterable<ResultD_>> mapping) {
BavetFlattenLastBridgeQuadConstraintStream<Solution_, A, B, C, D, ResultD_> bridge = shareAndAddChild(
new BavetFlattenLastBridgeQuadConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetFlattenLastQuadConstraintStream<>(constraintFactory, bridge),
bridge::setFlattenLastStream);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> QuadConstraintBuilderImpl<A, B, C, D, Score_> newTerminator(
BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new QuadConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName, constraintWeight_,
impactType_, justificationMapping, indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final PentaFunction<A, B, C, D, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return InnerQuadConstraintStream.createDefaultJustificationMapping();
}
@Override
protected final QuadFunction<A, B, C, D, Collection<?>> getDefaultIndictedObjectsMapping() {
return InnerQuadConstraintStream.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/quad/BavetBiGroupBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetGroupBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
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 BavetBiGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> 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/quad/BavetFilterQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
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.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
public final class BavetFilterQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private final QuadPredicate<A, B, C, D> predicate;
public BavetFilterQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadPredicate<A, B, C, D> predicate) {
super(constraintFactory, parent.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.<QuadTuple<A, B, C, D>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalQuadTupleLifecycle<>(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 BavetFilterQuadConstraintStream) {
BavetFilterQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetFilterQuadConstraintStream<?, ?, ?, ?, ?>) 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/quad/BavetFlattenLastBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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 BavetFlattenLastBridgeQuadConstraintStream<Solution_, A, B, C, D, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private final Function<D, Iterable<NewD>> mappingFunction;
private BavetFlattenLastQuadConstraintStream<Solution_, A, B, C, NewD> flattenLastStream;
public BavetFlattenLastBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
Function<D, Iterable<NewD>> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setFlattenLastStream(BavetFlattenLastQuadConstraintStream<Solution_, A, B, C, NewD> 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<QuadTuple<A, B, C, D>, QuadTuple<A, B, C, NewD>, D, NewD> node =
new FlattenLastQuadNode<>(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/quad/BavetFlattenLastQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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 BavetFlattenLastQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetFlattenLastQuadConstraintStream(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/quad/BavetGroupQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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 BavetGroupQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetGroupQuadConstraintStream(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/quad/BavetIfExistsQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.penta.DefaultPentaJoiner;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.score.Score;
final class BavetIfExistsQuadConstraintStream<Solution_, A, B, C, D, E>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD;
private final BavetIfExistsBridgeUniConstraintStream<Solution_, E> parentBridgeE;
private final boolean shouldExist;
private final DefaultPentaJoiner<A, B, C, D, E> joiner;
private final PentaPredicate<A, B, C, D, E> filtering;
public BavetIfExistsQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD,
BavetIfExistsBridgeUniConstraintStream<Solution_, E> parentBridgeE,
boolean shouldExist,
DefaultPentaJoiner<A, B, C, D, E> joiner, PentaPredicate<A, B, C, D, E> filtering) {
super(constraintFactory, parentABCD.getRetrievalSemantics());
this.parentABCD = parentABCD;
this.parentBridgeE = parentBridgeE;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABCD.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABCD.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeE.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABCD.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractIfExistsNode<QuadTuple<A, B, C, D>, E> node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsQuadNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsQuadNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
filtering))
: (filtering == null ? new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()), downstream)
: new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, parentBridgeE);
}
// ************************************************************************
// 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/quad/BavetJoinQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import java.util.Set;
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.tri.BavetJoinBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetJoinBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.common.quad.DefaultQuadJoiner;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
public final class BavetJoinQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetJoinConstraintStream<Solution_> {
private final BavetJoinBridgeTriConstraintStream<Solution_, A, B, C> leftParent;
private final BavetJoinBridgeUniConstraintStream<Solution_, D> rightParent;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetJoinQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetJoinBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetJoinBridgeUniConstraintStream<Solution_, D> rightParent,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>> node =
indexerFactory.hasJoiners()
? new IndexedJoinQuadNode<>(
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 UnindexedJoinQuadNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetJoinQuadConstraintStream<?, ?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this join node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent())
&& Objects.equals(joiner, other.joiner)
&& Objects.equals(filtering, other.filtering);
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent(), joiner, filtering);
}
@Override
public String toString() {
return "QuadJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
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/quad/BavetMapBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Set;
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.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
public final class BavetMapBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private final QuadFunction<A, B, C, D, NewA> mappingFunction;
private BavetMapUniConstraintStream<Solution_, NewA> mapStream;
public BavetMapBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, 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<QuadTuple<A, B, C, D>, NewA> node = new MapQuadNode<>(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/quad/BavetQuadGroupBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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 BavetQuadGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
protected final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
protected BavetGroupQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> groupStream;
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
public BavetQuadGroupBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> 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/quad/BavetScoringQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.common.inliner.JustificationsSupplier.of;
import java.math.BigDecimal;
import java.util.Set;
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.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;
public final class BavetScoringQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetScoringConstraintStream<Solution_> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
private final boolean noMatchWeigher;
private final ToIntQuadFunction<A, B, C, D> intMatchWeigher;
private final ToLongQuadFunction<A, B, C, D> longMatchWeigher;
private final QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
ToIntQuadFunction<A, B, C, D> intMatchWeigher) {
this(constraintFactory, parent, false, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
ToLongQuadFunction<A, B, C, D> longMatchWeigher) {
this(constraintFactory, parent, false, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, false, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
boolean noMatchWeigher,
ToIntQuadFunction<A, B, C, D> intMatchWeigher, ToLongQuadFunction<A, B, C, D> longMatchWeigher,
QuadFunction<A, B, C, D, 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();
QuadFunction<A, B, C, D, UndoScoreImpacter> scoreImpacter;
if (intMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c, d) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c, d);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c, d);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c, d) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c, d);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (longMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c, d) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c, d);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c, d);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c, d) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c, d);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (bigDecimalMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c, d) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c, d);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c, d);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c, d) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c, d);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (noMatchWeigher) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c, d) -> {
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c, d);
return weightedScoreImpacter.impactScore(1, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c, d) -> weightedScoreImpacter.impactScore(1, null);
}
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
QuadScorer<A, B, C, D> scorer = new QuadScorer<>(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/quad/BavetTriGroupBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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 BavetTriGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
protected final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
protected BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream;
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
public BavetTriGroupBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> 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/quad/BavetUniGroupBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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 BavetUniGroupBridgeQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
protected final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent;
protected BavetGroupUniConstraintStream<Solution_, NewA> groupStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> 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/quad/ConditionalQuadTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConditionalTupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadPredicate;
final class ConditionalQuadTupleLifecycle<A, B, C, D> extends AbstractConditionalTupleLifecycle<QuadTuple<A, B, C, D>> {
private final QuadPredicate<A, B, C, D> predicate;
public ConditionalQuadTupleLifecycle(QuadPredicate<A, B, C, D> predicate,
TupleLifecycle<QuadTuple<A, B, C, D>> tupleLifecycle) {
super(tupleLifecycle);
this.predicate = predicate;
}
@Override
protected boolean test(QuadTuple<A, B, C, D> tuple) {
return predicate.test(tuple.getFactA(), tuple.getFactB(), tuple.getFactC(), tuple.getFactD());
}
}
|
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/quad/FlattenLastQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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 FlattenLastQuadNode<A, B, C, D, NewD>
extends AbstractFlattenLastNode<QuadTuple<A, B, C, D>, QuadTuple<A, B, C, NewD>, D, NewD> {
private final int outputStoreSize;
FlattenLastQuadNode(int flattenLastStoreIndex, Function<D, Iterable<NewD>> mappingFunction,
TupleLifecycle<QuadTuple<A, B, C, NewD>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, NewD> createTuple(QuadTuple<A, B, C, D> originalTuple, NewD newD) {
return new QuadTupleImpl<>(originalTuple.getFactA(), originalTuple.getFactB(), originalTuple.getFactC(), newD,
outputStoreSize);
}
@Override
protected D getEffectiveFactIn(QuadTuple<A, B, C, D> tuple) {
return tuple.getFactD();
}
@Override
protected NewD getEffectiveFactOut(QuadTuple<A, B, C, NewD> outTuple) {
return outTuple.getFactD();
}
}
|
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/quad/Group0Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group0Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, ResultContainer_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, UniTuple<A>, UniTupleImpl<A>, Void, ResultContainer_, A> {
private final int outputStoreSize;
public Group0Mapping1CollectorQuadNode(int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group0Mapping2CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
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.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group0Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<A, B>, BiTupleImpl<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorQuadNode(int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerA_, A> collectorA,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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, OldC, OldD, A, B, ResultContainerA_, ResultContainerB_>
QuadConstraintCollector<OldA, OldB, OldC, OldD, Object, Pair<A, B>> mergeCollectors(
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerA_, A> collectorA,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB) {
return (QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group0Mapping3CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group0Mapping3CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorQuadNode(int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerA_, A> collectorA,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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, OldC, OldD, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
QuadConstraintCollector<OldA, OldB, OldC, OldD, Object, Triple<A, B, C>> mergeCollectors(
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerA_, A> collectorA,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC) {
return (QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group0Mapping4CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group0Mapping4CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorQuadNode(int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerA_, A> collectorA,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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;
}
static <OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
QuadConstraintCollector<OldA, OldB, OldC, OldD, Object, Quadruple<A, B, C, D>> mergeCollectors(
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerA_, A> collectorA,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerD_, D> collectorD) {
return (QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group1Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, UniTuple<A>, UniTupleImpl<A>, A, Void, Void> {
private final int outputStoreSize;
public Group1Mapping0CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, 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, OldC, OldD> A createGroupKey(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMapping,
QuadTuple<OldA, OldB, OldC, OldD> tuple) {
return groupKeyMapping.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC(), tuple.getFactD());
}
@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/quad/Group1Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group1Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, ResultContainer_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<A, B>, BiTupleImpl<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMapping, int groupStoreIndex,
int undoStoreIndex, QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group1Mapping2CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group1Mapping0CollectorQuadNode.createGroupKey;
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.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group1Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, A, Object, Pair<B, C>> {
private final int outputStoreSize;
public Group1Mapping2CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMapping, int groupStoreIndex,
int undoStoreIndex, QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorQuadNode.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/quad/Group1Mapping3CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group0Mapping3CollectorQuadNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group1Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group1Mapping3CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMapping, int groupStoreIndex,
int undoStoreIndex, QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group2Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<A, B>, BiTupleImpl<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, 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, OldC, OldD> Pair<A, B> createGroupKey(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadTuple<OldA, OldB, OldC, OldD> tuple) {
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
OldD oldD = tuple.getFactD();
A a = groupKeyMappingA.apply(oldA, oldB, oldC, oldD);
B b = groupKeyMappingB.apply(oldA, oldB, oldC, oldD);
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/quad/Group2Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group2Mapping0CollectorQuadNode.createGroupKey;
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.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, ResultContainer_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Pair<A, B>, ResultContainer_, C> {
private final int outputStoreSize;
public Group2Mapping1CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group2Mapping2CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group0Mapping2CollectorQuadNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group2Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group3Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadFunction<OldA, OldB, OldC, OldD, 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, OldC, OldD> Triple<A, B, C> createGroupKey(
QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB,
QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
QuadTuple<OldA, OldB, OldC, OldD> tuple) {
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
OldD oldD = tuple.getFactD();
A a = groupKeyMappingA.apply(oldA, oldB, oldC, oldD);
B b = groupKeyMappingB.apply(oldA, oldB, oldC, oldD);
C c = groupKeyMappingC.apply(oldA, oldB, oldC, oldD);
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/quad/Group3Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group3Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainer_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Triple<A, B, C>, ResultContainer_, D> {
private final int outputStoreSize;
public Group3Mapping1CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, 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/quad/Group4Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group4Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
QuadFunction<OldA, OldB, OldC, OldD, 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, OldC, OldD> Quadruple<A, B, C, D> createGroupKey(
QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB,
QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
QuadFunction<OldA, OldB, OldC, OldD, D> groupKeyMappingD,
QuadTuple<OldA, OldB, OldC, OldD> tuple) {
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
OldD oldD = tuple.getFactD();
A a = groupKeyMappingA.apply(oldA, oldB, oldC, oldD);
B b = groupKeyMappingB.apply(oldA, oldB, oldC, oldD);
C c = groupKeyMappingC.apply(oldA, oldB, oldC, oldD);
D d = groupKeyMappingD.apply(oldA, oldB, oldC, oldD);
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/quad/IndexedIfExistsQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.PentaPredicate;
import ai.timefold.solver.core.api.function.QuadFunction;
final class IndexedIfExistsQuadNode<A, B, C, D, E> extends AbstractIndexedIfExistsNode<QuadTuple<A, B, C, D>, E> {
private final QuadFunction<A, B, C, D, IndexProperties> mappingABCD;
private final PentaPredicate<A, B, C, D, E> filtering;
public IndexedIfExistsQuadNode(boolean shouldExist,
QuadFunction<A, B, C, D, IndexProperties> mappingABCD, Function<E, IndexProperties> mappingE,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<QuadTuple<A, B, C, D>>> indexerABCD, Indexer<UniTuple<E>> indexerE) {
this(shouldExist, mappingABCD, mappingE,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, -1,
inputStoreIndexRightProperties, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, indexerABCD, indexerE,
null);
}
public IndexedIfExistsQuadNode(boolean shouldExist,
QuadFunction<A, B, C, D, IndexProperties> mappingABCD, Function<E, IndexProperties> mappingE,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<QuadTuple<A, B, C, D>>> indexerABCD, Indexer<UniTuple<E>> indexerE,
PentaPredicate<A, B, C, D, E> filtering) {
super(shouldExist, mappingE,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightProperties, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, indexerABCD, indexerE,
filtering != null);
this.mappingABCD = mappingABCD;
this.filtering = filtering;
}
@Override
protected IndexProperties createIndexProperties(QuadTuple<A, B, C, D> leftTuple) {
return mappingABCD.apply(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), leftTuple.getFactD());
}
@Override
protected boolean testFiltering(QuadTuple<A, B, C, D> leftTuple, UniTuple<E> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), leftTuple.getFactD(),
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/quad/IndexedJoinQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.function.TriFunction;
final class IndexedJoinQuadNode<A, B, C, D>
extends AbstractIndexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>> {
private final TriFunction<A, B, C, IndexProperties> mappingABC;
private final QuadPredicate<A, B, C, D> filtering;
private final int outputStoreSize;
public IndexedJoinQuadNode(TriFunction<A, B, C, IndexProperties> mappingABC, Function<D, IndexProperties> mappingD,
int inputStoreIndexABC, int inputStoreIndexEntryABC, int inputStoreIndexOutTupleListABC,
int inputStoreIndexD, int inputStoreIndexEntryD, int inputStoreIndexOutTupleListD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, QuadPredicate<A, B, C, D> filtering,
int outputStoreSize,
int outputStoreIndexOutEntryABC, int outputStoreIndexOutEntryD,
Indexer<TriTuple<A, B, C>> indexerABC,
Indexer<UniTuple<D>> indexerD) {
super(mappingD,
inputStoreIndexABC, inputStoreIndexEntryABC, inputStoreIndexOutTupleListABC,
inputStoreIndexD, inputStoreIndexEntryD, inputStoreIndexOutTupleListD,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexOutEntryABC, outputStoreIndexOutEntryD,
indexerABC, indexerD);
this.mappingABC = mappingABC;
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected IndexProperties createIndexPropertiesLeft(TriTuple<A, B, C> leftTuple) {
return mappingABC.apply(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC());
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return new QuadTupleImpl<>(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA(),
outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(QuadTupleImpl<A, B, C, D> outTuple, TriTuple<A, B, C> leftTuple) {
outTuple.factA = leftTuple.getFactA();
outTuple.factB = leftTuple.getFactB();
outTuple.factC = leftTuple.getFactC();
}
@Override
protected void setOutTupleRightFact(QuadTupleImpl<A, B, C, D> outTuple, UniTuple<D> rightTuple) {
outTuple.factD = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), 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/quad/MapQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
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;
import ai.timefold.solver.core.api.function.QuadFunction;
final class MapQuadNode<A, B, C, D, NewA> extends AbstractMapNode<QuadTuple<A, B, C, D>, NewA> {
private final QuadFunction<A, B, C, D, NewA> mappingFunction;
MapQuadNode(int mapStoreIndex, QuadFunction<A, B, C, D, NewA> mappingFunction,
TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
protected NewA map(QuadTuple<A, B, C, D> tuple) {
return mappingFunction.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC(), tuple.getFactD());
}
}
|
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/quad/QuadScorer.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractScorer;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
final class QuadScorer<A, B, C, D> extends AbstractScorer<QuadTuple<A, B, C, D>> {
private final QuadFunction<A, B, C, D, UndoScoreImpacter> scoreImpacter;
public QuadScorer(String constraintPackage, String constraintName, Score<?> constraintWeight,
QuadFunction<A, B, C, D, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(constraintPackage, constraintName, constraintWeight, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(QuadTuple<A, B, C, D> tuple) {
try {
return scoreImpacter.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC(), tuple.getFactD());
} 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/quad/QuadTuple.java |
package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.Tuple;
public interface QuadTuple<A, B, C, D> extends Tuple {
A getFactA();
B getFactB();
C getFactC();
D getFactD();
}
|
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/quad/QuadTupleImpl.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractTuple;
public final class QuadTupleImpl<A, B, C, D> extends AbstractTuple implements QuadTuple<A, B, C, D> {
// Only a tuple's origin node may modify a fact.
public A factA;
public B factB;
public C factC;
public D factD;
public QuadTupleImpl(A factA, B factB, C factC, D factD, int storeSize) {
super(storeSize);
this.factA = factA;
this.factB = factB;
this.factC = factC;
this.factD = factD;
}
@Override
public A getFactA() {
return factA;
}
@Override
public B getFactB() {
return factB;
}
@Override
public C getFactC() {
return factC;
}
@Override
public D getFactD() {
return factD;
}
@Override
public String toString() {
return "{" + factA + ", " + factB + ", " + factC + ", " + factD + "}";
}
}
|
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/quad/UnindexedIfExistsQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.PentaPredicate;
final class UnindexedIfExistsQuadNode<A, B, C, D, E> extends AbstractUnindexedIfExistsNode<QuadTuple<A, B, C, D>, E> {
private final PentaPredicate<A, B, C, D, E> filtering;
public UnindexedIfExistsQuadNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightEntry,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle) {
this(shouldExist,
inputStoreIndexLeftCounterEntry, -1,
inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public UnindexedIfExistsQuadNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
PentaPredicate<A, B, C, D, E> filtering) {
super(shouldExist,
inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(QuadTuple<A, B, C, D> leftTuple, UniTuple<E> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), leftTuple.getFactD(),
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/quad/UnindexedJoinQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
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.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.QuadPredicate;
final class UnindexedJoinQuadNode<A, B, C, D>
extends AbstractUnindexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>> {
private final QuadPredicate<A, B, C, D> filtering;
private final int outputStoreSize;
public UnindexedJoinQuadNode(
int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, QuadPredicate<A, B, C, D> 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 QuadTupleImpl<A, B, C, D> createOutTuple(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return new QuadTupleImpl<>(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA(),
outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(QuadTupleImpl<A, B, C, D> outTuple, TriTuple<A, B, C> leftTuple) {
outTuple.factA = leftTuple.getFactA();
outTuple.factB = leftTuple.getFactB();
outTuple.factC = leftTuple.getFactC();
}
@Override
protected void setOutTupleRightFact(QuadTupleImpl<A, B, C, D> outTuple, UniTuple<D> rightTuple) {
outTuple.factD = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), 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/tri/AbstractGroupTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.QuadFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
abstract class AbstractGroupTriNode<OldA, OldB, OldC, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_, GroupKey_, ResultContainer_, Result_>
extends
AbstractGroupNode<TriTuple<OldA, OldB, OldC>, OutTuple_, MutableOutTuple_, GroupKey_, ResultContainer_, Result_> {
private final QuadFunction<ResultContainer_, OldA, OldB, OldC, Runnable> accumulator;
protected AbstractGroupTriNode(int groupStoreIndex, int undoStoreIndex,
Function<TriTuple<OldA, OldB, OldC>, GroupKey_> groupKeyFunction,
TriConstraintCollector<OldA, OldB, OldC, 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 AbstractGroupTriNode(int groupStoreIndex, Function<TriTuple<OldA, OldB, OldC>, GroupKey_> groupKeyFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
super(groupStoreIndex, groupKeyFunction, nextNodesTupleLifecycle, environmentMode);
accumulator = null;
}
@Override
protected final Runnable accumulate(ResultContainer_ resultContainer, TriTuple<OldA, OldB, OldC> tuple) {
return accumulator.apply(resultContainer, tuple.getFactA(), tuple.getFactB(), tuple.getFactC());
}
}
|
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/tri/BavetAbstractTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetGroupBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
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.BavetJoinQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
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.quad.QuadJoinerComber;
import ai.timefold.solver.constraint.streams.common.tri.InnerTriConstraintStream;
import ai.timefold.solver.constraint.streams.common.tri.TriConstraintBuilderImpl;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
public abstract class BavetAbstractTriConstraintStream<Solution_, A, B, C> extends BavetAbstractConstraintStream<Solution_>
implements InnerTriConstraintStream<A, B, C> {
protected final List<BavetAbstractTriConstraintStream<Solution_, A, B, C>> childStreamList = new ArrayList<>(2);
public BavetAbstractTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
public List<BavetAbstractTriConstraintStream<Solution_, A, B, C>> getChildStreamList() {
return childStreamList;
}
// ************************************************************************
// Stream builder methods
// ************************************************************************
public <Stream_ extends BavetAbstractTriConstraintStream<Solution_, A, B, C>> Stream_ shareAndAddChild(
Stream_ stream) {
return constraintFactory.share(stream, childStreamList::add);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public BavetAbstractTriConstraintStream<Solution_, A, B, C> filter(TriPredicate<A, B, C> predicate) {
return shareAndAddChild(
new BavetFilterTriConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// Join
// ************************************************************************
@Override
@SafeVarargs
public final <D> QuadConstraintStream<A, B, C, D> join(UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>... joiners) {
BavetAbstractUniConstraintStream<Solution_, D> other = assertBavetUniConstraintStream(otherStream);
QuadJoinerComber<A, B, C, D> joinerComber = QuadJoinerComber.comb(joiners);
BavetJoinBridgeTriConstraintStream<Solution_, A, B, C> leftBridge =
new BavetJoinBridgeTriConstraintStream<>(constraintFactory, this, true);
BavetJoinBridgeUniConstraintStream<Solution_, D> rightBridge =
new BavetJoinBridgeUniConstraintStream<>(constraintFactory, other, false);
BavetJoinQuadConstraintStream<Solution_, A, B, C, D> joinStream =
new BavetJoinQuadConstraintStream<>(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 <D> TriConstraintStream<A, B, C> ifExists(Class<D> otherClass, QuadJoiner<A, B, C, D>... 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 <D> TriConstraintStream<A, B, C> ifExistsIncludingNullVars(Class<D> otherClass,
QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEachIncludingNullVars(otherClass), joiners);
} else {
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <D> TriConstraintStream<A, B, C> ifExists(UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final <D> TriConstraintStream<A, B, C> ifNotExists(Class<D> otherClass, QuadJoiner<A, B, C, D>... 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 <D> TriConstraintStream<A, B, C> ifNotExistsIncludingNullVars(Class<D> otherClass,
QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEachIncludingNullVars(otherClass), joiners);
} else {
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <D> TriConstraintStream<A, B, C> ifNotExists(UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <D> TriConstraintStream<A, B, C> ifExistsOrNot(boolean shouldExist, UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>[] joiners) {
BavetAbstractUniConstraintStream<Solution_, D> other = assertBavetUniConstraintStream(otherStream);
QuadJoinerComber<A, B, C, D> joinerComber = QuadJoinerComber.comb(joiners);
BavetIfExistsBridgeUniConstraintStream<Solution_, D> parentBridgeD = other.shareAndAddChild(
new BavetIfExistsBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsTriConstraintStream<>(constraintFactory, this, parentBridgeD,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group0Mapping1CollectorTriNode<>(groupStoreIndex, undoStoreIndex,
collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA>
buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
BavetUniGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA> bridge = shareAndAddChild(
new BavetUniGroupBridgeTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupUniConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group0Mapping2CollectorTriNode<>(groupStoreIndex, undoStoreIndex, collectorA,
collectorB, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
BavetBiGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA, NewB> bridge = shareAndAddChild(
new BavetBiGroupBridgeTriConstraintStream<>(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(TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group0Mapping3CollectorTriNode<>(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) {
BavetTriGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC> bridge = shareAndAddChild(
new BavetTriGroupBridgeTriConstraintStream<>(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(TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group0Mapping4CollectorTriNode<>(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) {
BavetQuadGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC, NewD> bridge = shareAndAddChild(
new BavetQuadGroupBridgeTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupQuadConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(TriFunction<A, B, C, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group1Mapping0CollectorTriNode<>(
groupKeyMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_> groupBy(TriFunction<A, B, C, GroupKey_> groupKeyMapping,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping2CollectorTriNode<>(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(TriFunction<A, B, C, GroupKey_> groupKeyMapping,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping3CollectorTriNode<>(groupKeyMapping, groupStoreIndex, undoStoreIndex,
collectorB, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
TriFunction<A, B, C, GroupKey_> groupKeyMapping,
TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group1Mapping1CollectorTriNode<>(groupKeyMapping, groupStoreIndex,
undoStoreIndex, collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group2Mapping0CollectorTriNode<>(
groupKeyAMapping, groupKeyBMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_> groupBy(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping1CollectorTriNode<>(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(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping2CollectorTriNode<>(groupKeyAMapping, groupKeyBMapping, groupStoreIndex,
undoStoreIndex, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping, TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor = of((groupStoreIndex,
tupleLifecycle, outputStoreSize, environmentMode) -> new Group3Mapping0CollectorTriNode<>(groupKeyAMapping,
groupKeyBMapping, groupKeyCMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group3Mapping1CollectorTriNode<>(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping,
groupStoreIndex, undoStoreIndex, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping,
TriFunction<A, B, C, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group4Mapping0CollectorTriNode<>(
groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping, groupStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public <ResultA_> UniConstraintStream<ResultA_> map(TriFunction<A, B, C, ResultA_> mapping) {
BavetMapBridgeTriConstraintStream<Solution_, A, B, C, ResultA_> bridge = shareAndAddChild(
new BavetMapBridgeTriConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetMapUniConstraintStream<>(constraintFactory, bridge),
bridge::setMapStream);
}
@Override
public <ResultC_> TriConstraintStream<A, B, ResultC_> flattenLast(Function<C, Iterable<ResultC_>> mapping) {
BavetFlattenLastBridgeTriConstraintStream<Solution_, A, B, C, ResultC_> bridge = shareAndAddChild(
new BavetFlattenLastBridgeTriConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetFlattenLastTriConstraintStream<>(constraintFactory, bridge),
bridge::setFlattenLastStream);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> TriConstraintBuilderImpl<A, B, C, Score_>
newTerminator(BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new TriConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName, constraintWeight_,
impactType_, justificationMapping, indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final QuadFunction<A, B, C, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return InnerTriConstraintStream.createDefaultJustificationMapping();
}
@Override
protected final TriFunction<A, B, C, Collection<?>> getDefaultIndictedObjectsMapping() {
return InnerTriConstraintStream.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/tri/BavetBiGroupBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetGroupBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
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 BavetBiGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA, NewB>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> 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/tri/BavetFilterTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
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.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
public final class BavetFilterTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private final TriPredicate<A, B, C> predicate;
public BavetFilterTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriPredicate<A, B, C> predicate) {
super(constraintFactory, parent.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.<TriTuple<A, B, C>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalTriTupleLifecycle<>(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 BavetFilterTriConstraintStream) {
BavetFilterTriConstraintStream<?, ?, ?, ?> other = (BavetFilterTriConstraintStream<?, ?, ?, ?>) 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/tri/BavetFlattenLastBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 BavetFlattenLastBridgeTriConstraintStream<Solution_, A, B, C, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private final Function<C, Iterable<NewC>> mappingFunction;
private BavetFlattenLastTriConstraintStream<Solution_, A, B, NewC> flattenLastStream;
public BavetFlattenLastBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
Function<C, Iterable<NewC>> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setFlattenLastStream(BavetFlattenLastTriConstraintStream<Solution_, A, B, NewC> 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<TriTuple<A, B, C>, TriTuple<A, B, NewC>, C, NewC> node = new FlattenLastTriNode<>(
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/tri/BavetFlattenLastTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 BavetFlattenLastTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetFlattenLastTriConstraintStream(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/tri/BavetGroupTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 BavetGroupTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetGroupTriConstraintStream(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/tri/BavetIfExistsTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.quad.DefaultQuadJoiner;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
final class BavetIfExistsTriConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC;
private final BavetIfExistsBridgeUniConstraintStream<Solution_, D> parentBridgeD;
private final boolean shouldExist;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetIfExistsTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC,
BavetIfExistsBridgeUniConstraintStream<Solution_, D> parentBridgeD,
boolean shouldExist,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, parentABC.getRetrievalSemantics());
this.parentABC = parentABC;
this.parentBridgeD = parentBridgeD;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABC.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABC.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeD.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABC.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractIfExistsNode<TriTuple<A, B, C>, D> node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsTriNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsTriNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
filtering))
: (filtering == null ? new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()), downstream)
: new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, parentBridgeD);
}
// ************************************************************************
// 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/tri/BavetJoinBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 BavetJoinBridgeTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private final boolean isLeftBridge;
private BavetJoinConstraintStream<Solution_> joinStream;
public BavetJoinBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> 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 BavetAbstractTriConstraintStream<Solution_, A, B, C> getParent() {
return parent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetJoinQuadConstraintStream, 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/tri/BavetJoinTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetJoinBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
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.common.tri.DefaultTriJoiner;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
public final class BavetJoinTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetJoinConstraintStream<Solution_> {
private final BavetJoinBridgeBiConstraintStream<Solution_, A, B> leftParent;
private final BavetJoinBridgeUniConstraintStream<Solution_, C> rightParent;
private final DefaultTriJoiner<A, B, C> joiner;
private final TriPredicate<A, B, C> filtering;
public BavetJoinTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetJoinBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetJoinBridgeUniConstraintStream<Solution_, C> rightParent,
DefaultTriJoiner<A, B, C> joiner, TriPredicate<A, B, C> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory indexerFactory = new IndexerFactory(joiner);
AbstractJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>, TriTupleImpl<A, B, C>> node = indexerFactory.hasJoiners()
? new IndexedJoinTriNode<>(
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 UnindexedJoinTriNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinTriConstraintStream<?, ?, ?, ?> other = (BavetJoinTriConstraintStream<?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this join node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent())
&& Objects.equals(joiner, other.joiner)
&& Objects.equals(filtering, other.filtering);
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent(), joiner, filtering);
}
@Override
public String toString() {
return "TriJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
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/tri/BavetMapBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Set;
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.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
public final class BavetMapBridgeTriConstraintStream<Solution_, A, B, C, NewA>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private final TriFunction<A, B, C, NewA> mappingFunction;
private BavetMapUniConstraintStream<Solution_, NewA> mapStream;
public BavetMapBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, 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<TriTuple<A, B, C>, NewA> node = new MapTriNode<>(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/tri/BavetQuadGroupBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 BavetQuadGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC, NewD>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private BavetGroupQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> groupStream;
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
public BavetQuadGroupBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> 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/tri/BavetScoringTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.common.inliner.JustificationsSupplier.of;
import java.math.BigDecimal;
import java.util.Set;
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.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;
public final class BavetScoringTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetScoringConstraintStream<Solution_> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private final boolean noMatchWeigher;
private final ToIntTriFunction<A, B, C> intMatchWeigher;
private final ToLongTriFunction<A, B, C> longMatchWeigher;
private final TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
ToIntTriFunction<A, B, C> intMatchWeigher) {
this(constraintFactory, parent, false, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
ToLongTriFunction<A, B, C> longMatchWeigher) {
this(constraintFactory, parent, false, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, false, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
boolean noMatchWeigher,
ToIntTriFunction<A, B, C> intMatchWeigher, ToLongTriFunction<A, B, C> longMatchWeigher,
TriFunction<A, B, C, 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();
TriFunction<A, B, C, UndoScoreImpacter> scoreImpacter;
if (intMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (longMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (bigDecimalMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (noMatchWeigher) {
if (constraintMatchEnabled) {
scoreImpacter = (a, b, c) -> {
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a, b,
c);
return weightedScoreImpacter.impactScore(1, justificationsSupplier);
};
} else {
scoreImpacter = (a, b, c) -> weightedScoreImpacter.impactScore(1, null);
}
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
TriScorer<A, B, C> scorer = new TriScorer<>(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/tri/BavetTriGroupBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 BavetTriGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream;
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
public BavetTriGroupBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> 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/tri/BavetUniGroupBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 BavetUniGroupBridgeTriConstraintStream<Solution_, A, B, C, NewA>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parent;
private BavetGroupUniConstraintStream<Solution_, NewA> groupStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> 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/tri/ConditionalTriTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConditionalTupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriPredicate;
final class ConditionalTriTupleLifecycle<A, B, C> extends AbstractConditionalTupleLifecycle<TriTuple<A, B, C>> {
private final TriPredicate<A, B, C> predicate;
public ConditionalTriTupleLifecycle(TriPredicate<A, B, C> predicate, TupleLifecycle<TriTuple<A, B, C>> tupleLifecycle) {
super(tupleLifecycle);
this.predicate = predicate;
}
@Override
protected boolean test(TriTuple<A, B, C> tuple) {
return predicate.test(tuple.getFactA(), tuple.getFactB(), tuple.getFactC());
}
}
|
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/tri/FlattenLastTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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 FlattenLastTriNode<A, B, C, NewC>
extends AbstractFlattenLastNode<TriTuple<A, B, C>, TriTuple<A, B, NewC>, C, NewC> {
private final int outputStoreSize;
FlattenLastTriNode(int flattenLastStoreIndex, Function<C, Iterable<NewC>> mappingFunction,
TupleLifecycle<TriTuple<A, B, NewC>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, NewC> createTuple(TriTuple<A, B, C> originalTuple, NewC newC) {
return new TriTupleImpl<>(originalTuple.getFactA(), originalTuple.getFactB(), newC, outputStoreSize);
}
@Override
protected C getEffectiveFactIn(TriTuple<A, B, C> tuple) {
return tuple.getFactC();
}
@Override
protected NewC getEffectiveFactOut(TriTuple<A, B, NewC> outTuple) {
return outTuple.getFactC();
}
}
|
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/tri/Group0Mapping1CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group0Mapping1CollectorTriNode<OldA, OldB, OldC, A, ResultContainer_>
extends AbstractGroupTriNode<OldA, OldB, OldC, UniTuple<A>, UniTupleImpl<A>, Void, ResultContainer_, A> {
private final int outputStoreSize;
public Group0Mapping1CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group0Mapping2CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group0Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, BiTupleImpl<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, 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, OldC, A, B, ResultContainerA_, ResultContainerB_>
TriConstraintCollector<OldA, OldB, OldC, Object, Pair<A, B>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB) {
return (TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group0Mapping3CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group0Mapping3CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, 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, OldC, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
TriConstraintCollector<OldA, OldB, OldC, Object, Triple<A, B, C>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC) {
return (TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group0Mapping4CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group0Mapping4CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, 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;
}
static <OldA, OldB, OldC, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
TriConstraintCollector<OldA, OldB, OldC, Object, Quadruple<A, B, C, D>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD) {
return (TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group1Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.function.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping0CollectorTriNode<OldA, OldB, OldC, A>
extends AbstractGroupTriNode<OldA, OldB, OldC, UniTuple<A>, UniTupleImpl<A>, A, Void, Void> {
private final int outputStoreSize;
public Group1Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, 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, OldC> A createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
TriTuple<OldA, OldB, OldC> tuple) {
return groupKeyMapping.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC());
}
@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/tri/Group1Mapping1CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group1Mapping0CollectorTriNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, ResultContainer_>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, BiTupleImpl<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping, int groupStoreIndex,
int undoStoreIndex, TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group1Mapping2CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group1Mapping0CollectorTriNode.createGroupKey;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group1Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, A, Object, Pair<B, C>> {
private final int outputStoreSize;
public Group1Mapping2CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping, int groupStoreIndex,
int undoStoreIndex, TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorTriNode.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/tri/Group1Mapping3CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group0Mapping3CollectorTriNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group1Mapping0CollectorTriNode.createGroupKey;
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.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group1Mapping3CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping, int groupStoreIndex,
int undoStoreIndex, TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group2Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping0CollectorTriNode<OldA, OldB, OldC, A, B>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, BiTupleImpl<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, 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, OldC> Pair<A, B> createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriTuple<OldA, OldB, OldC> tuple) {
OldA oldA = tuple.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
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/tri/Group2Mapping1CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group2Mapping0CollectorTriNode.createGroupKey;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainer_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, TriTupleImpl<A, B, C>, Pair<A, B>, ResultContainer_, C> {
private final int outputStoreSize;
public Group2Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group2Mapping2CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group0Mapping2CollectorTriNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group2Mapping0CollectorTriNode.createGroupKey;
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.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, QuadTupleImpl<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, 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();
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.