index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractFlattenLastNode.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
public abstract class AbstractFlattenLastNode<InTuple_ extends AbstractTuple, OutTuple_ extends AbstractTuple, EffectiveItem_, FlattenedItem_>
extends AbstractNode
implements TupleLifecycle<InTuple_> {
private final int flattenLastStoreIndex;
private final Function<EffectiveItem_, Iterable<FlattenedItem_>> mappingFunction;
private final StaticPropagationQueue<OutTuple_> propagationQueue;
protected AbstractFlattenLastNode(int flattenLastStoreIndex,
Function<EffectiveItem_, Iterable<FlattenedItem_>> mappingFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle) {
this.flattenLastStoreIndex = flattenLastStoreIndex;
this.mappingFunction = Objects.requireNonNull(mappingFunction);
this.propagationQueue = new StaticPropagationQueue<>(nextNodesTupleLifecycle);
}
@Override
public final void insert(InTuple_ tuple) {
if (tuple.getStore(flattenLastStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
Iterable<FlattenedItem_> iterable = mappingFunction.apply(getEffectiveFactIn(tuple));
if (iterable instanceof Collection<FlattenedItem_> collection) {
// Optimization for Collection, where we know the size.
int size = collection.size();
if (size == 0) {
return;
}
List<OutTuple_> outTupleList = new ArrayList<>(size);
for (FlattenedItem_ item : collection) {
addTuple(tuple, item, outTupleList);
}
tuple.setStore(flattenLastStoreIndex, outTupleList);
} else {
Iterator<FlattenedItem_> iterator = iterable.iterator();
if (!iterator.hasNext()) {
return;
}
List<OutTuple_> outTupleList = new ArrayList<>();
while (iterator.hasNext()) {
addTuple(tuple, iterator.next(), outTupleList);
}
tuple.setStore(flattenLastStoreIndex, outTupleList);
}
}
private void addTuple(InTuple_ originalTuple, FlattenedItem_ item, List<OutTuple_> outTupleList) {
OutTuple_ tuple = createTuple(originalTuple, item);
outTupleList.add(tuple);
propagationQueue.insert(tuple);
}
protected abstract OutTuple_ createTuple(InTuple_ originalTuple, FlattenedItem_ item);
@Override
public final void update(InTuple_ tuple) {
List<OutTuple_> outTupleList = tuple.getStore(flattenLastStoreIndex);
if (outTupleList == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s).
insert(tuple);
return;
}
Iterable<FlattenedItem_> iterable = mappingFunction.apply(getEffectiveFactIn(tuple));
List<FlattenedItem_> newFlattenedItemList = iterableToList(iterable);
if (newFlattenedItemList.isEmpty()) { // Everything has to be removed.
retract(tuple);
return;
}
if (!outTupleList.isEmpty()) {
// Remove all facts from the input that already have an out tuple.
Iterator<OutTuple_> outTupleIterator = outTupleList.iterator();
while (outTupleIterator.hasNext()) {
OutTuple_ outTuple = outTupleIterator.next();
FlattenedItem_ existingFlattenedItem = getEffectiveFactOut(outTuple);
boolean existsAlsoInNew = false;
if (!newFlattenedItemList.isEmpty()) {
// A fact can be present more than once and every iteration should only remove one instance.
Iterator<FlattenedItem_> newFlattenedItemIterator = newFlattenedItemList.iterator();
while (newFlattenedItemIterator.hasNext()) {
FlattenedItem_ newFlattenedItem = newFlattenedItemIterator.next();
// We check for identity, not equality, to not introduce dependency on user equals().
if (newFlattenedItem == existingFlattenedItem) {
// Remove item from the list, as it means its tuple need not be added later.
newFlattenedItemIterator.remove();
existsAlsoInNew = true;
break;
}
}
}
if (!existsAlsoInNew) {
outTupleIterator.remove();
removeTuple(outTuple);
} else {
propagationQueue.update(outTuple);
}
}
}
// Whatever is left in the input needs to be added.
for (FlattenedItem_ newFlattenedItem : newFlattenedItemList) {
addTuple(tuple, newFlattenedItem, outTupleList);
}
}
private List<FlattenedItem_> iterableToList(Iterable<FlattenedItem_> iterable) {
if (iterable instanceof Collection<FlattenedItem_> collection) {
// Optimization for Collection, where we know the size.
int size = collection.size();
if (size == 0) {
return Collections.emptyList();
}
List<FlattenedItem_> result = new ArrayList<>(size);
iterable.forEach(result::add);
return result;
} else {
Iterator<FlattenedItem_> iterator = iterable.iterator();
if (!iterator.hasNext()) {
return Collections.emptyList();
}
List<FlattenedItem_> result = new ArrayList<>();
while (iterator.hasNext()) {
result.add(iterator.next());
}
return result;
}
}
protected abstract EffectiveItem_ getEffectiveFactIn(InTuple_ tuple);
protected abstract FlattenedItem_ getEffectiveFactOut(OutTuple_ outTuple);
@Override
public final void retract(InTuple_ tuple) {
List<OutTuple_> outTupleList = tuple.removeStore(flattenLastStoreIndex);
if (outTupleList == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
for (OutTuple_ item : outTupleList) {
removeTuple(item);
}
}
private void removeTuple(OutTuple_ outTuple) {
TupleState state = outTuple.state;
if (!state.isActive()) {
throw new IllegalStateException("Impossible state: The tuple (" + outTuple +
") is in an unexpected state (" + outTuple.state + ").");
}
propagationQueue.retract(outTuple, state == TupleState.CREATING ? TupleState.ABORTING : TupleState.DYING);
}
@Override
public Propagator getPropagator() {
return propagationQueue;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractGroupNode.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
public abstract class AbstractGroupNode<InTuple_ extends AbstractTuple, OutTuple_ extends AbstractTuple, GroupKey_, ResultContainer_, Result_>
extends AbstractNode
implements TupleLifecycle<InTuple_> {
private final int groupStoreIndex;
/**
* Unused when {@link #hasCollector} is false.
*/
private final int undoStoreIndex;
/**
* Unused when {@link #hasMultipleGroups} is false.
*/
private final Function<InTuple_, GroupKey_> groupKeyFunction;
/**
* Unused when {@link #hasCollector} is false.
*/
private final Supplier<ResultContainer_> supplier;
/**
* Unused when {@link #hasCollector} is false.
*/
private final Function<ResultContainer_, Result_> finisher;
/**
* Some code paths may decide to not supply a grouping function.
* In that case, every tuple accumulates into {@link #singletonGroup} and not to {@link #groupMap}.
*/
private final boolean hasMultipleGroups;
/**
* Some code paths may decide to not supply a collector.
* In that case, we skip the code path that would attempt to use it.
*/
private final boolean hasCollector;
/**
* Used when {@link #hasMultipleGroups} is true, otherwise {@link #singletonGroup} is used.
*/
private final Map<Object, Group<OutTuple_, ResultContainer_>> groupMap;
/**
* Used when {@link #hasMultipleGroups} is false, otherwise {@link #groupMap} is used.
*
* @implNote The field is lazy initialized in order to maintain the same semantics as with the groupMap above.
* When all tuples are removed, the field will be set to null, as if the group never existed.
*/
private Group<OutTuple_, ResultContainer_> singletonGroup;
private final DynamicPropagationQueue<OutTuple_, Group<OutTuple_, ResultContainer_>> propagationQueue;
private final boolean useAssertingGroupKey;
protected AbstractGroupNode(int groupStoreIndex, int undoStoreIndex,
Function<InTuple_, GroupKey_> groupKeyFunction, Supplier<ResultContainer_> supplier,
Function<ResultContainer_, Result_> finisher,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
this.groupStoreIndex = groupStoreIndex;
this.undoStoreIndex = undoStoreIndex;
this.groupKeyFunction = groupKeyFunction;
this.supplier = supplier;
this.finisher = finisher;
this.hasMultipleGroups = groupKeyFunction != null;
this.hasCollector = supplier != null;
/*
* Not using the default sizing to 1000.
* The number of groups can be very small, and that situation is not unlikely.
* Therefore, the size of these collections is kept default.
*/
this.groupMap = hasMultipleGroups ? new HashMap<>() : null;
this.propagationQueue = hasCollector ? new DynamicPropagationQueue<>(nextNodesTupleLifecycle,
group -> {
var outTuple = group.getTuple();
var state = outTuple.state;
if (state == TupleState.CREATING || state == TupleState.UPDATING) {
updateOutTupleToFinisher(outTuple, group.getResultContainer());
}
}) : new DynamicPropagationQueue<>(nextNodesTupleLifecycle);
this.useAssertingGroupKey = environmentMode.isStepAssertOrMore();
}
protected AbstractGroupNode(int groupStoreIndex,
Function<InTuple_, GroupKey_> groupKeyFunction, TupleLifecycle<OutTuple_> nextNodesTupleLifecycle,
EnvironmentMode environmentMode) {
this(groupStoreIndex, -1,
groupKeyFunction, null, null, nextNodesTupleLifecycle,
environmentMode);
}
@Override
public final void insert(InTuple_ tuple) {
if (tuple.getStore(groupStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
var userSuppliedKey = hasMultipleGroups ? groupKeyFunction.apply(tuple) : null;
createTuple(tuple, userSuppliedKey);
}
private void createTuple(InTuple_ tuple, GroupKey_ userSuppliedKey) {
var newGroup = getOrCreateGroup(userSuppliedKey);
var outTuple = accumulate(tuple, newGroup);
switch (outTuple.state) {
case CREATING, UPDATING -> {
// Already in the correct state.
}
case OK, DYING -> propagationQueue.update(newGroup);
case ABORTING -> propagationQueue.insert(newGroup);
default -> throw new IllegalStateException("Impossible state: The group (" + newGroup + ") in node (" + this
+ ") is in an unexpected state (" + outTuple.state + ").");
}
}
private OutTuple_ accumulate(InTuple_ tuple, Group<OutTuple_, ResultContainer_> group) {
if (hasCollector) {
var undoAccumulator = accumulate(group.getResultContainer(), tuple);
tuple.setStore(undoStoreIndex, undoAccumulator);
}
tuple.setStore(groupStoreIndex, group);
return group.getTuple();
}
private Group<OutTuple_, ResultContainer_> getOrCreateGroup(GroupKey_ userSuppliedKey) {
var groupMapKey = useAssertingGroupKey ? new AssertingGroupKey<>(userSuppliedKey) : userSuppliedKey;
if (hasMultipleGroups) {
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
var group = groupMap.get(groupMapKey);
if (group == null) {
group = createGroupWithGroupKey(groupMapKey);
groupMap.put(groupMapKey, group);
} else {
group.parentCount++;
}
return group;
} else {
if (singletonGroup == null) {
singletonGroup = createGroupWithoutGroupKey();
} else {
singletonGroup.parentCount++;
}
return singletonGroup;
}
}
private Group<OutTuple_, ResultContainer_> createGroupWithGroupKey(Object groupMapKey) {
var userSuppliedKey = extractUserSuppliedKey(groupMapKey);
var outTuple = createOutTuple(userSuppliedKey);
var group = hasCollector ? Group.create(groupMapKey, supplier.get(), outTuple)
: Group.<OutTuple_, ResultContainer_> createWithoutAccumulate(groupMapKey, outTuple);
propagationQueue.insert(group);
return group;
}
private Group<OutTuple_, ResultContainer_> createGroupWithoutGroupKey() {
var outTuple = createOutTuple(null);
if (!hasCollector) {
throw new IllegalStateException("Impossible state: The node (" + this + ") has no collector, "
+ "but it is still trying to create a group without a group key.");
}
var group = Group.createWithoutGroupKey(supplier.get(), outTuple);
propagationQueue.insert(group);
return group;
}
@SuppressWarnings("unchecked")
private GroupKey_ extractUserSuppliedKey(Object groupMapKey) {
return useAssertingGroupKey ? ((AssertingGroupKey<GroupKey_>) groupMapKey).key() : (GroupKey_) groupMapKey;
}
@Override
public final void update(InTuple_ tuple) {
Group<OutTuple_, ResultContainer_> oldGroup = tuple.getStore(groupStoreIndex);
if (oldGroup == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insert(tuple);
return;
}
if (hasCollector) {
Runnable undoAccumulator = tuple.getStore(undoStoreIndex);
undoAccumulator.run();
}
var oldUserSuppliedGroupKey = hasMultipleGroups ? extractUserSuppliedKey(oldGroup.getGroupKey()) : null;
var newUserSuppliedGroupKey = hasMultipleGroups ? groupKeyFunction.apply(tuple) : null;
if (Objects.equals(newUserSuppliedGroupKey, oldUserSuppliedGroupKey)) {
// No need to change parentCount because it is the same group
var outTuple = accumulate(tuple, oldGroup);
switch (outTuple.state) {
case CREATING, UPDATING -> {
// Already in the correct state.
}
case OK -> propagationQueue.update(oldGroup);
default -> throw new IllegalStateException("Impossible state: The group (" + oldGroup + ") in node (" + this
+ ") is in an unexpected state (" + outTuple.state + ").");
}
} else {
killTuple(oldGroup);
createTuple(tuple, newUserSuppliedGroupKey);
}
}
private void killTuple(Group<OutTuple_, ResultContainer_> group) {
var newParentCount = --group.parentCount;
var killGroup = (newParentCount == 0);
if (killGroup) {
var groupKey = hasMultipleGroups ? group.getGroupKey() : null;
var oldGroup = removeGroup(groupKey);
if (oldGroup == null) {
throw new IllegalStateException("Impossible state: the group for the groupKey ("
+ groupKey + ") doesn't exist in the groupMap.\n" +
"Maybe groupKey hashcode changed while it shouldn't have?");
}
}
var outTuple = group.getTuple();
switch (outTuple.state) {
case CREATING -> {
if (killGroup) {
propagationQueue.retract(group, TupleState.ABORTING);
}
}
case UPDATING -> {
if (killGroup) {
propagationQueue.retract(group, TupleState.DYING);
}
}
case OK -> {
if (killGroup) {
propagationQueue.retract(group, TupleState.DYING);
} else {
propagationQueue.update(group);
}
}
default -> throw new IllegalStateException("Impossible state: The group (" + group + ") in node (" + this
+ ") is in an unexpected state (" + outTuple.state + ").");
}
}
private Group<OutTuple_, ResultContainer_> removeGroup(Object groupKey) {
if (hasMultipleGroups) {
return groupMap.remove(groupKey);
} else {
var oldGroup = singletonGroup;
singletonGroup = null;
return oldGroup;
}
}
@Override
public final void retract(InTuple_ tuple) {
Group<OutTuple_, ResultContainer_> group = tuple.removeStore(groupStoreIndex);
if (group == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
if (hasCollector) {
Runnable undoAccumulator = tuple.removeStore(undoStoreIndex);
undoAccumulator.run();
}
killTuple(group);
}
protected abstract Runnable accumulate(ResultContainer_ resultContainer, InTuple_ tuple);
@Override
public Propagator getPropagator() {
return propagationQueue;
}
/**
*
* @param groupKey null if the node only has one group
* @return never null
*/
protected abstract OutTuple_ createOutTuple(GroupKey_ groupKey);
private void updateOutTupleToFinisher(OutTuple_ outTuple, ResultContainer_ resultContainer) {
updateOutTupleToResult(outTuple, finisher.apply(resultContainer));
}
protected abstract void updateOutTupleToResult(OutTuple_ outTuple, Result_ result);
/**
* Group key hashcode must never change once introduced to the group map.
* If it does, unpredictable behavior will occur.
* Since this situation is far too frequent and users run into this,
* we have this helper class that will optionally throw an exception when it detects this.
*/
private record AssertingGroupKey<GroupKey_>(GroupKey_ key, int initialHashCode) {
public AssertingGroupKey(GroupKey_ key) {
this(key, key == null ? 0 : key.hashCode());
}
public GroupKey_ key() {
if (key != null && key.hashCode() != initialHashCode) {
throw new IllegalStateException(
"""
hashCode of object (%s) of class (%s) has changed while it was being used as a group key.
Group key hashCode must consistently return the same integer, as required by the general hashCode contract."""
.formatted(key, key.getClass().getName()));
}
return key;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractGroupNodeConstructor.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
abstract sealed class AbstractGroupNodeConstructor<Tuple_ extends AbstractTuple>
implements GroupNodeConstructor<Tuple_>
permits GroupNodeConstructorWithAccumulate, GroupNodeConstructorWithoutAccumulate {
private final Object equalityKey;
protected AbstractGroupNodeConstructor(Object equalityKey) {
this.equalityKey = equalityKey;
}
@Override
public boolean equals(Object o) {
return o instanceof AbstractGroupNodeConstructor<?> that
&& Objects.equals(getClass(), that.getClass())
&& Objects.equals(equalityKey, that.equalityKey);
}
@Override
public int hashCode() {
return Objects.hashCode(equalityKey);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractIfExistsNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* This class has two direct children: {@link AbstractIndexedIfExistsNode} and {@link AbstractUnindexedIfExistsNode}.
* The logic in either is identical, except that the latter removes all indexing work.
* Therefore any time that one of the classes changes,
* the other should be inspected if it could benefit from applying the change there too.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractIfExistsNode<LeftTuple_ extends AbstractTuple, Right_>
extends AbstractTwoInputNode<LeftTuple_, UniTuple<Right_>> {
protected final boolean shouldExist;
protected final int inputStoreIndexLeftTrackerList; // -1 if !isFiltering
protected final int inputStoreIndexRightTrackerList; // -1 if !isFiltering
protected final boolean isFiltering;
private final DynamicPropagationQueue<LeftTuple_, ExistsCounter<LeftTuple_>> propagationQueue;
protected AbstractIfExistsNode(boolean shouldExist,
int inputStoreIndexLeftTrackerList, int inputStoreIndexRightTrackerList,
TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle,
boolean isFiltering) {
this.shouldExist = shouldExist;
this.inputStoreIndexLeftTrackerList = inputStoreIndexLeftTrackerList;
this.inputStoreIndexRightTrackerList = inputStoreIndexRightTrackerList;
this.isFiltering = isFiltering;
this.propagationQueue = new DynamicPropagationQueue<>(nextNodesTupleLifecycle);
}
protected abstract boolean testFiltering(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple);
protected void initCounterLeft(ExistsCounter<LeftTuple_> counter) {
if (shouldExist ? counter.countRight > 0 : counter.countRight == 0) {
// Counters start out dead
propagationQueue.insert(counter);
}
}
protected final void updateUnchangedCounterLeft(ExistsCounter<LeftTuple_> counter) {
if (counter.state != TupleState.OK) {
// Counter state does not change because the index keys didn't change
return;
}
// Still needed to propagate the update for downstream filters, matchWeighers, ...
propagationQueue.update(counter);
}
protected void updateCounterLeft(ExistsCounter<LeftTuple_> counter) {
TupleState state = counter.state;
if (shouldExist ? counter.countRight > 0 : counter.countRight == 0) {
// Insert or update
switch (state) {
case CREATING, UPDATING -> {
// Don't add the tuple to the propagation queue twice
}
case OK, DYING -> propagationQueue.update(counter);
case DEAD, ABORTING -> propagationQueue.insert(counter);
default -> throw new IllegalStateException("Impossible state: the counter (" + counter
+ ") has an impossible insert state (" + state + ").");
}
} else {
// Retract or remain dead
if (!state.isActive()) {
// Don't add the tuple to the propagation queue twice.
return;
}
switch (state) {
case CREATING -> // Kill it before it propagates.
propagationQueue.retract(counter, TupleState.ABORTING);
case OK, UPDATING -> // Kill the original propagation.
propagationQueue.retract(counter, TupleState.DYING);
default -> throw new IllegalStateException("Impossible state: The counter (" + counter
+ ") has an impossible retract state (" + state + ").");
}
}
}
protected void killCounterLeft(ExistsCounter<LeftTuple_> counter) {
if (shouldExist ? counter.countRight > 0 : counter.countRight == 0) {
doRetractCounter(counter);
}
}
protected void incrementCounterRight(ExistsCounter<LeftTuple_> counter) {
if (counter.countRight == 0) {
if (shouldExist) {
doInsertCounter(counter);
} else {
doRetractCounter(counter);
}
} // Else do not even propagate an update
counter.countRight++;
}
protected void decrementCounterRight(ExistsCounter<LeftTuple_> counter) {
counter.countRight--;
if (counter.countRight == 0) {
if (shouldExist) {
doRetractCounter(counter);
} else {
doInsertCounter(counter);
}
} // Else do not even propagate an update
}
protected ElementAwareList<FilteringTracker<LeftTuple_>> updateRightTrackerList(UniTuple<Right_> rightTuple) {
ElementAwareList<FilteringTracker<LeftTuple_>> rightTrackerList = rightTuple.getStore(inputStoreIndexRightTrackerList);
for (FilteringTracker<LeftTuple_> tuple : rightTrackerList) {
decrementCounterRight(tuple.counter);
tuple.remove();
}
return rightTrackerList;
}
protected void updateCounterFromLeft(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter,
ElementAwareList<FilteringTracker<LeftTuple_>> leftTrackerList) {
if (testFiltering(leftTuple, rightTuple)) {
counter.countRight++;
ElementAwareList<FilteringTracker<LeftTuple_>> rightTrackerList =
rightTuple.getStore(inputStoreIndexRightTrackerList);
new FilteringTracker<>(counter, leftTrackerList, rightTrackerList);
}
}
protected void updateCounterFromRight(UniTuple<Right_> rightTuple, ExistsCounter<LeftTuple_> counter,
ElementAwareList<FilteringTracker<LeftTuple_>> rightTrackerList) {
if (testFiltering(counter.leftTuple, rightTuple)) {
incrementCounterRight(counter);
ElementAwareList<FilteringTracker<LeftTuple_>> leftTrackerList =
counter.leftTuple.getStore(inputStoreIndexLeftTrackerList);
new FilteringTracker<>(counter, leftTrackerList, rightTrackerList);
}
}
private void doInsertCounter(ExistsCounter<LeftTuple_> counter) {
switch (counter.state) {
case DYING -> propagationQueue.update(counter);
case DEAD, ABORTING -> propagationQueue.insert(counter);
default -> throw new IllegalStateException("Impossible state: the counter (" + counter
+ ") has an impossible insert state (" + counter.state + ").");
}
}
private void doRetractCounter(ExistsCounter<LeftTuple_> counter) {
switch (counter.state) {
case CREATING -> // Kill it before it propagates.
propagationQueue.retract(counter, TupleState.ABORTING);
case OK, UPDATING -> // Kill the original propagation.
propagationQueue.retract(counter, TupleState.DYING);
default -> throw new IllegalStateException("Impossible state: The counter (" + counter
+ ") has an impossible retract state (" + counter.state + ").");
}
}
@Override
public Propagator getPropagator() {
return propagationQueue;
}
protected static final class FilteringTracker<LeftTuple_ extends AbstractTuple> {
final ExistsCounter<LeftTuple_> counter;
private final ElementAwareListEntry<FilteringTracker<LeftTuple_>> leftTrackerEntry;
private final ElementAwareListEntry<FilteringTracker<LeftTuple_>> rightTrackerEntry;
FilteringTracker(ExistsCounter<LeftTuple_> counter, ElementAwareList<FilteringTracker<LeftTuple_>> leftTrackerList,
ElementAwareList<FilteringTracker<LeftTuple_>> rightTrackerList) {
this.counter = counter;
leftTrackerEntry = leftTrackerList.add(this);
rightTrackerEntry = rightTrackerList.add(this);
}
public void remove() {
leftTrackerEntry.remove();
rightTrackerEntry.remove();
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractIndexedIfExistsNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.index.Indexer;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory.KeysExtractor;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory.UniKeysExtractor;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.LeftTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.RightTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* There is a strong likelihood that any change to this class, which is not related to indexing,
* should also be made to {@link AbstractUnindexedIfExistsNode}.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractIndexedIfExistsNode<LeftTuple_ extends AbstractTuple, Right_>
extends AbstractIfExistsNode<LeftTuple_, Right_>
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
private final KeysExtractor<LeftTuple_> keysExtractorLeft;
private final UniKeysExtractor<Right_> keysExtractorRight;
private final int inputStoreIndexLeftKeys;
private final int inputStoreIndexLeftCounterEntry;
private final int inputStoreIndexRightKeys;
private final int inputStoreIndexRightEntry;
private final Indexer<ExistsCounter<LeftTuple_>> indexerLeft;
private final Indexer<UniTuple<Right_>> indexerRight;
protected AbstractIndexedIfExistsNode(boolean shouldExist,
KeysExtractor<LeftTuple_> keysExtractorLeft, IndexerFactory<Right_> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<LeftTuple_> nextNodesTupleLifecycle,
boolean isFiltering) {
super(shouldExist,
inputStoreIndexLeftTrackerList, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, isFiltering);
this.keysExtractorLeft = keysExtractorLeft;
this.keysExtractorRight = indexerFactory.buildRightKeysExtractor();
this.inputStoreIndexLeftKeys = inputStoreIndexLeftKeys;
this.inputStoreIndexLeftCounterEntry = inputStoreIndexLeftCounterEntry;
this.inputStoreIndexRightKeys = inputStoreIndexRightKeys;
this.inputStoreIndexRightEntry = inputStoreIndexRightEntry;
this.indexerLeft = indexerFactory.buildIndexer(true);
this.indexerRight = indexerFactory.buildIndexer(false);
}
@Override
public final void insertLeft(LeftTuple_ leftTuple) {
if (leftTuple.getStore(inputStoreIndexLeftKeys) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + leftTuple
+ ") was already added in the tupleStore.");
}
var indexKeys = keysExtractorLeft.apply(leftTuple);
leftTuple.setStore(inputStoreIndexLeftKeys, indexKeys);
var counter = new ExistsCounter<>(leftTuple);
var counterEntry = indexerLeft.put(indexKeys, counter);
updateCounterRight(leftTuple, indexKeys, counter, counterEntry);
initCounterLeft(counter);
}
private void updateCounterRight(LeftTuple_ leftTuple, Object indexKeys, ExistsCounter<LeftTuple_> counter,
ElementAwareListEntry<ExistsCounter<LeftTuple_>> counterEntry) {
leftTuple.setStore(inputStoreIndexLeftCounterEntry, counterEntry);
if (!isFiltering) {
counter.countRight = indexerRight.size(indexKeys);
} else {
var leftTrackerList = new ElementAwareList<FilteringTracker<LeftTuple_>>();
indexerRight.forEach(indexKeys,
rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter, leftTrackerList));
leftTuple.setStore(inputStoreIndexLeftTrackerList, leftTrackerList);
}
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
var oldIndexKeys = leftTuple.getStore(inputStoreIndexLeftKeys);
if (oldIndexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertLeft(leftTuple);
return;
}
var newIndexKeys = keysExtractorLeft.apply(leftTuple);
ElementAwareListEntry<ExistsCounter<LeftTuple_>> counterEntry = leftTuple.getStore(inputStoreIndexLeftCounterEntry);
var counter = counterEntry.getElement();
if (oldIndexKeys.equals(newIndexKeys)) {
// No need for re-indexing because the index keys didn't change
// The indexers contain counters in the DEAD state, to track the rightCount.
if (!isFiltering) {
updateUnchangedCounterLeft(counter);
} else {
// Call filtering for the leftTuple and rightTuple combinations again
ElementAwareList<FilteringTracker<LeftTuple_>> leftTrackerList =
leftTuple.getStore(inputStoreIndexLeftTrackerList);
leftTrackerList.forEach(FilteringTracker::remove);
counter.countRight = 0;
indexerRight.forEach(oldIndexKeys,
rightTuple -> updateCounterFromLeft(leftTuple, rightTuple, counter, leftTrackerList));
updateCounterLeft(counter);
}
} else {
updateIndexerLeft(oldIndexKeys, counterEntry, leftTuple);
counter.countRight = 0;
leftTuple.setStore(inputStoreIndexLeftKeys, newIndexKeys);
updateCounterRight(leftTuple, newIndexKeys, counter, indexerLeft.put(newIndexKeys, counter));
updateCounterLeft(counter);
}
}
@Override
public final void retractLeft(LeftTuple_ leftTuple) {
var indexKeys = leftTuple.removeStore(inputStoreIndexLeftKeys);
if (indexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
ElementAwareListEntry<ExistsCounter<LeftTuple_>> counterEntry = leftTuple.getStore(inputStoreIndexLeftCounterEntry);
var counter = counterEntry.getElement();
updateIndexerLeft(indexKeys, counterEntry, leftTuple);
killCounterLeft(counter);
}
private void updateIndexerLeft(Object indexKeys, ElementAwareListEntry<ExistsCounter<LeftTuple_>> counterEntry,
LeftTuple_ leftTuple) {
indexerLeft.remove(indexKeys, counterEntry);
if (isFiltering) {
ElementAwareList<FilteringTracker<LeftTuple_>> leftTrackerList = leftTuple.getStore(inputStoreIndexLeftTrackerList);
leftTrackerList.forEach(FilteringTracker::remove);
}
}
@Override
public final void insertRight(UniTuple<Right_> rightTuple) {
if (rightTuple.getStore(inputStoreIndexRightKeys) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + rightTuple
+ ") was already added in the tupleStore.");
}
var indexKeys = keysExtractorRight.apply(rightTuple);
rightTuple.setStore(inputStoreIndexRightKeys, indexKeys);
var rightEntry = indexerRight.put(indexKeys, rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
updateCounterLeft(rightTuple, indexKeys);
}
private void updateCounterLeft(UniTuple<Right_> rightTuple, Object indexKeys) {
if (!isFiltering) {
indexerLeft.forEach(indexKeys, this::incrementCounterRight);
} else {
var rightTrackerList = new ElementAwareList<FilteringTracker<LeftTuple_>>();
indexerLeft.forEach(indexKeys, counter -> updateCounterFromRight(rightTuple, counter, rightTrackerList));
rightTuple.setStore(inputStoreIndexRightTrackerList, rightTrackerList);
}
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
var oldIndexKeys = rightTuple.getStore(inputStoreIndexRightKeys);
if (oldIndexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertRight(rightTuple);
return;
}
var newIndexKeys = keysExtractorRight.apply(rightTuple);
if (oldIndexKeys.equals(newIndexKeys)) {
// No need for re-indexing because the index keys didn't change
if (isFiltering) {
var rightTrackerList = updateRightTrackerList(rightTuple);
indexerLeft.forEach(oldIndexKeys,
counter -> updateCounterFromRight(rightTuple, counter, rightTrackerList));
}
} else {
ElementAwareListEntry<UniTuple<Right_>> rightEntry = rightTuple.getStore(inputStoreIndexRightEntry);
indexerRight.remove(oldIndexKeys, rightEntry);
if (!isFiltering) {
indexerLeft.forEach(oldIndexKeys, this::decrementCounterRight);
} else {
updateRightTrackerList(rightTuple);
}
rightTuple.setStore(inputStoreIndexRightKeys, newIndexKeys);
rightEntry = indexerRight.put(newIndexKeys, rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
updateCounterLeft(rightTuple, newIndexKeys);
}
}
@Override
public final void retractRight(UniTuple<Right_> rightTuple) {
var indexKeys = rightTuple.removeStore(inputStoreIndexRightKeys);
if (indexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
ElementAwareListEntry<UniTuple<Right_>> rightEntry = rightTuple.removeStore(inputStoreIndexRightEntry);
indexerRight.remove(indexKeys, rightEntry);
if (!isFiltering) {
indexerLeft.forEach(indexKeys, this::decrementCounterRight);
} else {
updateRightTrackerList(rightTuple);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractIndexedJoinNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.index.Indexer;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory.KeysExtractor;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory.UniKeysExtractor;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.LeftTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.RightTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* There is a strong likelihood that any change to this class, which is not related to indexing,
* should also be made to {@link AbstractUnindexedJoinNode}.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractIndexedJoinNode<LeftTuple_ extends AbstractTuple, Right_, OutTuple_ extends AbstractTuple>
extends AbstractJoinNode<LeftTuple_, Right_, OutTuple_>
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
private final KeysExtractor<LeftTuple_> keysExtractorLeft;
private final UniKeysExtractor<Right_> keysExtractorRight;
private final int inputStoreIndexLeftKeys;
private final int inputStoreIndexLeftEntry;
private final int inputStoreIndexRightKeys;
private final int inputStoreIndexRightEntry;
/**
* Calls for example {@link AbstractScorer#insert(AbstractTuple)} and/or ...
*/
private final Indexer<LeftTuple_> indexerLeft;
private final Indexer<UniTuple<Right_>> indexerRight;
protected AbstractIndexedJoinNode(KeysExtractor<LeftTuple_> keysExtractorLeft, IndexerFactory<Right_> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, boolean isFiltering, int outputStoreIndexLeftOutEntry,
int outputStoreIndexRightOutEntry) {
super(inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, nextNodesTupleLifecycle, isFiltering,
outputStoreIndexLeftOutEntry, outputStoreIndexRightOutEntry);
this.keysExtractorLeft = keysExtractorLeft;
this.keysExtractorRight = indexerFactory.buildRightKeysExtractor();
this.inputStoreIndexLeftKeys = inputStoreIndexLeftKeys;
this.inputStoreIndexLeftEntry = inputStoreIndexLeftEntry;
this.inputStoreIndexRightKeys = inputStoreIndexRightKeys;
this.inputStoreIndexRightEntry = inputStoreIndexRightEntry;
this.indexerLeft = indexerFactory.buildIndexer(true);
this.indexerRight = indexerFactory.buildIndexer(false);
}
@Override
public final void insertLeft(LeftTuple_ leftTuple) {
if (leftTuple.getStore(inputStoreIndexLeftKeys) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + leftTuple
+ ") was already added in the tupleStore.");
}
var indexKeys = keysExtractorLeft.apply(leftTuple);
var outTupleListLeft = new ElementAwareList<OutTuple_>();
leftTuple.setStore(inputStoreIndexLeftOutTupleList, outTupleListLeft);
indexAndPropagateLeft(leftTuple, indexKeys);
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
var oldIndexKeys = leftTuple.getStore(inputStoreIndexLeftKeys);
if (oldIndexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertLeft(leftTuple);
return;
}
var newIndexKeys = keysExtractorLeft.apply(leftTuple);
if (oldIndexKeys.equals(newIndexKeys)) {
// No need for re-indexing because the index keys didn't change
// Prefer an update over retract-insert if possible
innerUpdateLeft(leftTuple, consumer -> indexerRight.forEach(oldIndexKeys, consumer));
} else {
ElementAwareListEntry<LeftTuple_> leftEntry = leftTuple.getStore(inputStoreIndexLeftEntry);
ElementAwareList<OutTuple_> outTupleListLeft = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
indexerLeft.remove(oldIndexKeys, leftEntry);
outTupleListLeft.forEach(this::retractOutTuple);
// outTupleListLeft is now empty
// No need for leftTuple.setStore(inputStoreIndexLeftOutTupleList, outTupleListLeft);
indexAndPropagateLeft(leftTuple, newIndexKeys);
}
}
private void indexAndPropagateLeft(LeftTuple_ leftTuple, Object indexKeys) {
leftTuple.setStore(inputStoreIndexLeftKeys, indexKeys);
var leftEntry = indexerLeft.put(indexKeys, leftTuple);
leftTuple.setStore(inputStoreIndexLeftEntry, leftEntry);
indexerRight.forEach(indexKeys, rightTuple -> insertOutTupleFiltered(leftTuple, rightTuple));
}
@Override
public final void retractLeft(LeftTuple_ leftTuple) {
var indexKeys = leftTuple.removeStore(inputStoreIndexLeftKeys);
if (indexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
ElementAwareListEntry<LeftTuple_> leftEntry = leftTuple.removeStore(inputStoreIndexLeftEntry);
ElementAwareList<OutTuple_> outTupleListLeft = leftTuple.removeStore(inputStoreIndexLeftOutTupleList);
indexerLeft.remove(indexKeys, leftEntry);
outTupleListLeft.forEach(this::retractOutTuple);
}
@Override
public final void insertRight(UniTuple<Right_> rightTuple) {
if (rightTuple.getStore(inputStoreIndexRightKeys) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + rightTuple
+ ") was already added in the tupleStore.");
}
var indexKeys = keysExtractorRight.apply(rightTuple);
var outTupleListRight = new ElementAwareList<OutTuple_>();
rightTuple.setStore(inputStoreIndexRightOutTupleList, outTupleListRight);
indexAndPropagateRight(rightTuple, indexKeys);
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
var oldIndexKeys = rightTuple.getStore(inputStoreIndexRightKeys);
if (oldIndexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insertRight(rightTuple);
return;
}
var newIndexKeys = keysExtractorRight.apply(rightTuple);
if (oldIndexKeys.equals(newIndexKeys)) {
// No need for re-indexing because the index keys didn't change
// Prefer an update over retract-insert if possible
innerUpdateRight(rightTuple, consumer -> indexerLeft.forEach(oldIndexKeys, consumer));
} else {
ElementAwareListEntry<UniTuple<Right_>> rightEntry = rightTuple.getStore(inputStoreIndexRightEntry);
ElementAwareList<OutTuple_> outTupleListRight = rightTuple.getStore(inputStoreIndexRightOutTupleList);
indexerRight.remove(oldIndexKeys, rightEntry);
outTupleListRight.forEach(this::retractOutTuple);
// outTupleListRight is now empty
// No need for rightTuple.setStore(inputStoreIndexRightOutTupleList, outTupleListRight);
indexAndPropagateRight(rightTuple, newIndexKeys);
}
}
private void indexAndPropagateRight(UniTuple<Right_> rightTuple, Object indexKeys) {
rightTuple.setStore(inputStoreIndexRightKeys, indexKeys);
var rightEntry = indexerRight.put(indexKeys, rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
indexerLeft.forEach(indexKeys, leftTuple -> insertOutTupleFiltered(leftTuple, rightTuple));
}
@Override
public final void retractRight(UniTuple<Right_> rightTuple) {
var indexKeys = rightTuple.removeStore(inputStoreIndexRightKeys);
if (indexKeys == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
ElementAwareListEntry<UniTuple<Right_>> rightEntry = rightTuple.removeStore(inputStoreIndexRightEntry);
ElementAwareList<OutTuple_> outTupleListRight = rightTuple.removeStore(inputStoreIndexRightOutTupleList);
indexerRight.remove(indexKeys, rightEntry);
outTupleListRight.forEach(this::retractOutTuple);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractJoinNode.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.function.Consumer;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* This class has two direct children: {@link AbstractIndexedJoinNode} and {@link AbstractUnindexedJoinNode}.
* The logic in either is identical, except that the latter removes all indexing work.
* Therefore any time that one of the classes changes,
* the other should be inspected if it could benefit from applying the change there too.
*
* @param <LeftTuple_>
* @param <Right_>
*/
public abstract class AbstractJoinNode<LeftTuple_ extends AbstractTuple, Right_, OutTuple_ extends AbstractTuple>
extends AbstractTwoInputNode<LeftTuple_, UniTuple<Right_>> {
protected final int inputStoreIndexLeftOutTupleList;
protected final int inputStoreIndexRightOutTupleList;
private final boolean isFiltering;
private final int outputStoreIndexLeftOutEntry;
private final int outputStoreIndexRightOutEntry;
private final StaticPropagationQueue<OutTuple_> propagationQueue;
protected AbstractJoinNode(int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, boolean isFiltering,
int outputStoreIndexLeftOutEntry, int outputStoreIndexRightOutEntry) {
this.inputStoreIndexLeftOutTupleList = inputStoreIndexLeftOutTupleList;
this.inputStoreIndexRightOutTupleList = inputStoreIndexRightOutTupleList;
this.isFiltering = isFiltering;
this.outputStoreIndexLeftOutEntry = outputStoreIndexLeftOutEntry;
this.outputStoreIndexRightOutEntry = outputStoreIndexRightOutEntry;
this.propagationQueue = new StaticPropagationQueue<>(nextNodesTupleLifecycle);
}
protected abstract OutTuple_ createOutTuple(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple);
protected abstract void setOutTupleLeftFacts(OutTuple_ outTuple, LeftTuple_ leftTuple);
protected abstract void setOutTupleRightFact(OutTuple_ outTuple, UniTuple<Right_> rightTuple);
protected abstract boolean testFiltering(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple);
protected final void insertOutTuple(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple) {
var outTuple = createOutTuple(leftTuple, rightTuple);
ElementAwareList<OutTuple_> outTupleListLeft = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
var outEntryLeft = outTupleListLeft.add(outTuple);
outTuple.setStore(outputStoreIndexLeftOutEntry, outEntryLeft);
ElementAwareList<OutTuple_> outTupleListRight = rightTuple.getStore(inputStoreIndexRightOutTupleList);
var outEntryRight = outTupleListRight.add(outTuple);
outTuple.setStore(outputStoreIndexRightOutEntry, outEntryRight);
propagationQueue.insert(outTuple);
}
protected final void insertOutTupleFiltered(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple) {
if (!isFiltering || testFiltering(leftTuple, rightTuple)) {
insertOutTuple(leftTuple, rightTuple);
}
}
protected final void innerUpdateLeft(LeftTuple_ leftTuple, Consumer<Consumer<UniTuple<Right_>>> rightTupleConsumer) {
// Prefer an update over retract-insert if possible
ElementAwareList<OutTuple_> outTupleListLeft = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
// Propagate the update for downstream filters, matchWeighers, ...
if (!isFiltering) {
for (var outTuple : outTupleListLeft) {
updateOutTupleLeft(outTuple, leftTuple);
}
} else {
rightTupleConsumer.accept(rightTuple -> {
ElementAwareList<OutTuple_> rightOutList = rightTuple.getStore(inputStoreIndexRightOutTupleList);
processOutTupleUpdate(leftTuple, rightTuple, rightOutList, outTupleListLeft, outputStoreIndexRightOutEntry);
});
}
}
private void updateOutTupleLeft(OutTuple_ outTuple, LeftTuple_ leftTuple) {
setOutTupleLeftFacts(outTuple, leftTuple);
doUpdateOutTuple(outTuple);
}
private void doUpdateOutTuple(OutTuple_ outTuple) {
var state = outTuple.state;
if (!state.isActive()) { // Impossible because they shouldn't linger in the indexes.
throw new IllegalStateException("Impossible state: The tuple (%s) in node (%s) is in an unexpected state (%s)."
.formatted(outTuple, this, outTuple.state));
} else if (state != TupleState.OK) { // Already in the queue in the correct state.
return;
}
propagationQueue.update(outTuple);
}
protected final void innerUpdateRight(UniTuple<Right_> rightTuple, Consumer<Consumer<LeftTuple_>> leftTupleConsumer) {
// Prefer an update over retract-insert if possible
ElementAwareList<OutTuple_> outTupleListRight = rightTuple.getStore(inputStoreIndexRightOutTupleList);
if (!isFiltering) {
// Propagate the update for downstream filters, matchWeighers, ...
for (var outTuple : outTupleListRight) {
setOutTupleRightFact(outTuple, rightTuple);
doUpdateOutTuple(outTuple);
}
} else {
leftTupleConsumer.accept(leftTuple -> {
ElementAwareList<OutTuple_> leftOutList = leftTuple.getStore(inputStoreIndexLeftOutTupleList);
processOutTupleUpdate(leftTuple, rightTuple, leftOutList, outTupleListRight, outputStoreIndexLeftOutEntry);
});
}
}
private void processOutTupleUpdate(LeftTuple_ leftTuple, UniTuple<Right_> rightTuple, ElementAwareList<OutTuple_> outList,
ElementAwareList<OutTuple_> outTupleList, int outputStoreIndexOutEntry) {
var outTuple = findOutTuple(outTupleList, outList, outputStoreIndexOutEntry);
if (testFiltering(leftTuple, rightTuple)) {
if (outTuple == null) {
insertOutTuple(leftTuple, rightTuple);
} else {
updateOutTupleLeft(outTuple, leftTuple);
}
} else {
if (outTuple != null) {
retractOutTuple(outTuple);
}
}
}
private static <Tuple_ extends AbstractTuple> Tuple_ findOutTuple(ElementAwareList<Tuple_> outTupleList,
ElementAwareList<Tuple_> outList, int outputStoreIndexOutEntry) {
// Hack: the outTuple has no left/right input tuple reference, use the left/right outList reference instead.
var item = outTupleList.first();
while (item != null) {
// Creating list iterators here caused major GC pressure; therefore, we iterate over the entries directly.
var outTuple = item.getElement();
ElementAwareListEntry<Tuple_> outEntry = outTuple.getStore(outputStoreIndexOutEntry);
var outEntryList = outEntry.getList();
if (outList == outEntryList) {
return outTuple;
}
item = item.next();
}
return null;
}
protected final void retractOutTuple(OutTuple_ outTuple) {
ElementAwareListEntry<OutTuple_> outEntryLeft = outTuple.removeStore(outputStoreIndexLeftOutEntry);
outEntryLeft.remove();
ElementAwareListEntry<OutTuple_> outEntryRight = outTuple.removeStore(outputStoreIndexRightOutEntry);
outEntryRight.remove();
var state = outTuple.state;
if (!state.isActive()) { // Impossible because they shouldn't linger in the indexes.
throw new IllegalStateException("Impossible state: The tuple (%s) in node (%s) is in an unexpected state (%s)."
.formatted(outTuple, this, outTuple.state));
}
propagationQueue.retract(outTuple, state == TupleState.CREATING ? TupleState.ABORTING : TupleState.DYING);
}
@Override
public Propagator getPropagator() {
return propagationQueue;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractMapNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
public abstract class AbstractMapNode<InTuple_ extends AbstractTuple, OutTuple_ extends AbstractTuple>
extends AbstractNode
implements TupleLifecycle<InTuple_> {
private final int inputStoreIndex;
protected final int outputStoreSize;
private final StaticPropagationQueue<OutTuple_> propagationQueue;
protected AbstractMapNode(int inputStoreIndex, TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, int outputStoreSize) {
this.inputStoreIndex = inputStoreIndex;
this.outputStoreSize = outputStoreSize;
this.propagationQueue = new StaticPropagationQueue<>(nextNodesTupleLifecycle);
}
@Override
public final void insert(InTuple_ tuple) {
if (tuple.getStore(inputStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
OutTuple_ outTuple = map(tuple);
tuple.setStore(inputStoreIndex, outTuple);
propagationQueue.insert(outTuple);
}
protected abstract OutTuple_ map(InTuple_ inTuple);
@Override
public final void update(InTuple_ tuple) {
OutTuple_ outTuple = tuple.getStore(inputStoreIndex);
if (outTuple == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
insert(tuple);
return;
}
remap(tuple, outTuple);
// Update must be propagated even if outTuple did not change, since if it is a planning
// entity, the entity's planning variable might have changed.
TupleState previousState = outTuple.state;
if (previousState == TupleState.CREATING || previousState == TupleState.UPDATING) {
// Already in the queue in the correct state.
return;
}
propagationQueue.update(outTuple);
}
/**
* @param inTuple never null; the tuple to apply mappings on
* @param oldOutTuple never null; the tuple that was previously mapped to the inTuple
*/
protected abstract void remap(InTuple_ inTuple, OutTuple_ oldOutTuple);
@Override
public final void retract(InTuple_ tuple) {
OutTuple_ outTuple = tuple.removeStore(inputStoreIndex);
if (outTuple == null) {
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
return;
}
propagationQueue.retract(outTuple, outTuple.state == TupleState.CREATING ? TupleState.ABORTING : TupleState.DYING);
}
@Override
public Propagator getPropagator() {
return propagationQueue;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintSession;
/**
* @see PropagationQueue Description of the propagation mechanism.
*/
public abstract class AbstractNode {
private long id;
private long layerIndex = -1;
/**
* Instead of calling the propagation directly from here,
* we export the propagation queue and allow {@link BavetConstraintSession} to call it.
* This is done with the idea that {@link Propagator} only has two implementations
* (unlike {@link AbstractNode} with myriad implementations)
* and therefore JVM call site optimizations will kick in to make the method dispatch faster.
*
* @return never null; the {@link PropagationQueue} in use by this node
*/
public abstract Propagator getPropagator();
public long getId() {
return id;
}
public final void setId(long id) {
this.id = id;
}
public final void setLayerIndex(long layerIndex) {
if (layerIndex < 0) {
throw new IllegalArgumentException("Impossible state: layer index (" + layerIndex + ") must be at least 0.");
}
this.layerIndex = layerIndex;
}
public final long getLayerIndex() {
if (layerIndex == -1) {
throw new IllegalStateException(
"Impossible state: layer index for node (" + this + ") requested before being set.");
}
return layerIndex;
}
@Override
public String toString() {
// Useful for debugging if a constraint has multiple nodes of the same type
return getClass().getSimpleName() + "-" + id + "@" + layerIndex;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractNodeBuildHelper.java | package ai.timefold.solver.core.impl.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.TreeMap;
import java.util.function.BiConsumer;
import java.util.function.Consumer;
import java.util.function.UnaryOperator;
import ai.timefold.solver.core.impl.bavet.NodeNetwork;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.LeftTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.RightTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.uni.AbstractForEachUniNode;
public abstract class AbstractNodeBuildHelper<Stream_ extends BavetStream> {
private final Set<Stream_> activeStreamSet;
private final Map<AbstractNode, Stream_> nodeCreatorMap;
private final Map<Stream_, TupleLifecycle<? extends AbstractTuple>> tupleLifecycleMap;
private final Map<Stream_, Integer> storeIndexMap;
private List<AbstractNode> reversedNodeList;
protected AbstractNodeBuildHelper(Set<Stream_> activeStreamSet) {
this.activeStreamSet = activeStreamSet;
int activeStreamSetSize = activeStreamSet.size();
this.nodeCreatorMap = new HashMap<>(Math.max(16, activeStreamSetSize));
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(Stream_ stream) {
return activeStreamSet.contains(stream);
}
public void addNode(AbstractNode node, Stream_ creator) {
addNode(node, creator, creator);
}
public void addNode(AbstractNode node, Stream_ creator, Stream_ parent) {
reversedNodeList.add(node);
nodeCreatorMap.put(node, creator);
if (!(node instanceof AbstractForEachUniNode<?>)) {
if (parent == null) {
throw new IllegalStateException("Impossible state: The node (%s) has no parent (%s)."
.formatted(node, parent));
}
putInsertUpdateRetract(parent, (TupleLifecycle<? extends AbstractTuple>) node);
}
}
public void addNode(AbstractNode node, Stream_ creator, Stream_ leftParent, Stream_ rightParent) {
reversedNodeList.add(node);
nodeCreatorMap.put(node, creator);
putInsertUpdateRetract(leftParent, TupleLifecycle.ofLeft((LeftTupleLifecycle<? extends AbstractTuple>) node));
putInsertUpdateRetract(rightParent, TupleLifecycle.ofRight((RightTupleLifecycle<? extends AbstractTuple>) node));
}
public <Tuple_ extends AbstractTuple> void putInsertUpdateRetract(Stream_ stream,
TupleLifecycle<Tuple_> tupleLifecycle) {
tupleLifecycleMap.put(stream, tupleLifecycle);
}
public <Tuple_ extends AbstractTuple> void putInsertUpdateRetract(Stream_ stream, List<? extends Stream_> childStreamList,
UnaryOperator<TupleLifecycle<Tuple_>> tupleLifecycleFunction) {
TupleLifecycle<Tuple_> tupleLifecycle = getAggregatedTupleLifecycle(childStreamList);
putInsertUpdateRetract(stream, tupleLifecycleFunction.apply(tupleLifecycle));
}
@SuppressWarnings("unchecked")
public <Tuple_ extends AbstractTuple> TupleLifecycle<Tuple_>
getAggregatedTupleLifecycle(List<? extends Stream_> streamList) {
var tupleLifecycles = streamList.stream()
.filter(this::isStreamActive)
.map(s -> getTupleLifecycle(s, tupleLifecycleMap))
.toArray(TupleLifecycle[]::new);
return switch (tupleLifecycles.length) {
case 0 ->
throw new IllegalStateException("Impossible state: None of the streamList (%s) are active."
.formatted(streamList));
case 1 -> tupleLifecycles[0];
default -> TupleLifecycle.aggregate(tupleLifecycles);
};
}
@SuppressWarnings("unchecked")
private static <Stream_, Tuple_ extends AbstractTuple> TupleLifecycle<Tuple_> getTupleLifecycle(Stream_ stream,
Map<Stream_, TupleLifecycle<? extends AbstractTuple>> tupleLifecycleMap) {
var tupleLifecycle = (TupleLifecycle<Tuple_>) tupleLifecycleMap.get(stream);
if (tupleLifecycle == null) {
throw new IllegalStateException("Impossible state: the stream (%s) hasn't built a node yet."
.formatted(stream));
}
return tupleLifecycle;
}
public int reserveTupleStoreIndex(Stream_ tupleSourceStream) {
return storeIndexMap.compute(tupleSourceStream, (k, index) -> {
if (index == null) {
return 0;
} else if (index < 0) {
throw new IllegalStateException(
"Impossible state: the tupleSourceStream (%s) is reserving a store after it has been extracted."
.formatted(tupleSourceStream));
} else {
return index + 1;
}
});
}
public int extractTupleStoreSize(Stream_ 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;
}
public Stream_ getNodeCreatingStream(AbstractNode node) {
return nodeCreatorMap.get(node);
}
public AbstractNode findParentNode(Stream_ childNodeCreator) {
if (childNodeCreator == null) { // We've recursed to the bottom without finding a parent node.
throw new IllegalStateException("Impossible state: node-creating stream (%s) has no parent node."
.formatted(childNodeCreator));
}
// Look the stream up among node creators and if found, the node is the parent node.
for (Map.Entry<AbstractNode, Stream_> entry : this.nodeCreatorMap.entrySet()) {
if (entry.getValue() == childNodeCreator) {
return entry.getKey();
}
}
// Otherwise recurse to the parent node creator;
// this happens for bridges, filters and other streams that do not create nodes.
return findParentNode(childNodeCreator.getParent());
}
public static NodeNetwork buildNodeNetwork(List<AbstractNode> nodeList,
Map<Class<?>, List<AbstractForEachUniNode<?>>> declaredClassToNodeMap) {
var layerMap = new TreeMap<Long, List<Propagator>>();
for (var node : nodeList) {
layerMap.computeIfAbsent(node.getLayerIndex(), k -> new ArrayList<>())
.add(node.getPropagator());
}
var layerCount = layerMap.size();
var layeredNodes = new Propagator[layerCount][];
for (var i = 0; i < layerCount; i++) {
var layer = layerMap.get((long) i);
layeredNodes[i] = layer.toArray(new Propagator[0]);
}
return new NodeNetwork(declaredClassToNodeMap, layeredNodes);
}
public <BuildHelper_ extends AbstractNodeBuildHelper<Stream_>> List<AbstractNode> buildNodeList(Set<Stream_> streamSet,
BuildHelper_ buildHelper, BiConsumer<Stream_, BuildHelper_> nodeBuilder, Consumer<AbstractNode> nodeProcessor) {
/*
* Build streamSet in reverse order to create downstream nodes first
* so every node only has final variables (some of which have downstream node method references).
*/
var reversedStreamList = new ArrayList<>(streamSet);
Collections.reverse(reversedStreamList);
for (var constraintStream : reversedStreamList) {
nodeBuilder.accept(constraintStream, buildHelper);
}
var nodeList = buildHelper.destroyAndGetNodeList();
var nextNodeId = 0L;
for (var node : nodeList) {
/*
* Nodes are iterated first to last, starting with forEach(), the ultimate parent.
* Parents are guaranteed to come before children.
*/
node.setId(nextNodeId++);
node.setLayerIndex(determineLayerIndex(node, buildHelper));
nodeProcessor.accept(node);
}
return nodeList;
}
/**
* Nodes are propagated in layers.
* See {@link PropagationQueue} and {@link AbstractNode} for details.
* This method determines the layer of each node.
* It does so by reverse-engineering the parent nodes of each node.
* Nodes without parents (forEach nodes) are in layer 0.
* Nodes with parents are one layer above their parents.
* Some nodes have multiple parents, such as {@link AbstractJoinNode} and {@link AbstractIfExistsNode}.
* These are one layer above the highest parent.
* This is done to ensure that, when a child node starts propagating, all its parents have already propagated.
*
* @param node never null
* @param buildHelper never null
* @return at least 0
*/
@SuppressWarnings("unchecked")
private static <Stream_ extends BavetStream> long determineLayerIndex(AbstractNode node,
AbstractNodeBuildHelper<Stream_> buildHelper) {
if (node instanceof AbstractForEachUniNode<?>) { // ForEach nodes, and only they, are in layer 0.
return 0;
} else if (node instanceof AbstractTwoInputNode<?, ?> joinNode) {
var nodeCreator = (BavetStreamBinaryOperation<?>) buildHelper.getNodeCreatingStream(joinNode);
var leftParent = (Stream_) nodeCreator.getLeftParent();
var rightParent = (Stream_) nodeCreator.getRightParent();
var leftParentNode = buildHelper.findParentNode(leftParent);
var rightParentNode = buildHelper.findParentNode(rightParent);
return Math.max(leftParentNode.getLayerIndex(), rightParentNode.getLayerIndex()) + 1;
} else {
var nodeCreator = buildHelper.getNodeCreatingStream(node);
var parentNode = buildHelper.findParentNode(nodeCreator.getParent());
return parentNode.getLayerIndex() + 1;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractPropagationMetadataCarrier.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
/**
* {@link DynamicPropagationQueue} requires the items it carries to extend this class,
* in order to be able to store metadata on them.
* This metadata is necessary for efficient operation of the queue.
*/
sealed abstract class AbstractPropagationMetadataCarrier<Tuple_ extends AbstractTuple>
permits Group, ExistsCounter {
public int positionInDirtyList = -1;
public abstract Tuple_ getTuple();
public abstract TupleState getState();
public abstract void setState(TupleState state);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractScorer.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.score.stream.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.impl.score.stream.common.inliner.WeightedScoreImpacter;
public abstract class AbstractScorer<Tuple_ extends AbstractTuple> implements TupleLifecycle<Tuple_> {
protected final WeightedScoreImpacter<?, ?> weightedScoreImpacter;
private final int inputStoreIndex;
protected AbstractScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter, int inputStoreIndex) {
this.weightedScoreImpacter = weightedScoreImpacter;
this.inputStoreIndex = inputStoreIndex;
}
@Override
public final void insert(Tuple_ tuple) {
if (tuple.getStore(inputStoreIndex) != null) {
throw new IllegalStateException("Impossible state: the input for the tuple (" + tuple
+ ") was already added in the tupleStore.");
}
tuple.setStore(inputStoreIndex, impact(tuple));
}
@Override
public final void update(Tuple_ tuple) {
UndoScoreImpacter undoScoreImpacter = tuple.getStore(inputStoreIndex);
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
if (undoScoreImpacter != null) {
undoScoreImpacter.run();
}
tuple.setStore(inputStoreIndex, impact(tuple));
}
protected abstract UndoScoreImpacter impact(Tuple_ tuple);
/**
* Helps with debugging exceptions thrown by user code during impact calls.
*
* @param tuple never null
* @param cause never null
* @return never null, exception to be thrown.
*/
protected RuntimeException createExceptionOnImpact(Tuple_ tuple, Exception cause) {
return new IllegalStateException(
"Consequence of a constraint (" + weightedScoreImpacter.getContext().getConstraint().getConstraintRef()
+ ") threw an exception processing a tuple (" + tuple + ").",
cause);
}
@Override
public final void retract(Tuple_ tuple) {
UndoScoreImpacter undoScoreImpacter = tuple.getStore(inputStoreIndex);
// No fail fast if null because we don't track which tuples made it through the filter predicate(s)
if (undoScoreImpacter != null) {
undoScoreImpacter.run();
tuple.setStore(inputStoreIndex, null);
}
}
@Override
public final String toString() {
return getClass().getSimpleName() + "(" + weightedScoreImpacter.getContext().getConstraint().getConstraintRef()
+ ") with constraintWeight (" + weightedScoreImpacter.getContext().getConstraintWeight() + ")";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractTwoInputNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.LeftTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.RightTupleLifecycle;
public abstract class AbstractTwoInputNode<LeftTuple_ extends AbstractTuple, RightTuple_ extends AbstractTuple>
extends AbstractNode
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<RightTuple_> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractUnindexedIfExistsNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.LeftTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.RightTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* 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 AbstractTuple, 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 ElementAwareList<ExistsCounter<LeftTuple_>> leftCounterList = new ElementAwareList<>();
private final ElementAwareList<UniTuple<Right_>> rightTupleList = new ElementAwareList<>();
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.");
}
var counter = new ExistsCounter<>(leftTuple);
var counterEntry = leftCounterList.add(counter);
leftTuple.setStore(inputStoreIndexLeftCounterEntry, counterEntry);
if (!isFiltering) {
counter.countRight = rightTupleList.size();
} else {
var leftTrackerList = new ElementAwareList<FilteringTracker<LeftTuple_>>();
for (var tuple : rightTupleList) {
updateCounterFromLeft(leftTuple, tuple, counter, leftTrackerList);
}
leftTuple.setStore(inputStoreIndexLeftTrackerList, leftTrackerList);
}
initCounterLeft(counter);
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
ElementAwareListEntry<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;
}
var 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
ElementAwareList<FilteringTracker<LeftTuple_>> leftTrackerList = leftTuple.getStore(inputStoreIndexLeftTrackerList);
leftTrackerList.forEach(FilteringTracker::remove);
counter.countRight = 0;
for (var tuple : rightTupleList) {
updateCounterFromLeft(leftTuple, tuple, counter, leftTrackerList);
}
updateCounterLeft(counter);
}
}
@Override
public final void retractLeft(LeftTuple_ leftTuple) {
ElementAwareListEntry<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;
}
var counter = counterEntry.getElement();
counterEntry.remove();
if (isFiltering) {
ElementAwareList<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.");
}
var rightEntry = rightTupleList.add(rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
if (!isFiltering) {
leftCounterList.forEach(this::incrementCounterRight);
} else {
var rightTrackerList = new ElementAwareList<FilteringTracker<LeftTuple_>>();
for (var tuple : leftCounterList) {
updateCounterFromRight(rightTuple, tuple, rightTrackerList);
}
rightTuple.setStore(inputStoreIndexRightTrackerList, rightTrackerList);
}
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
ElementAwareListEntry<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) {
var rightTrackerList = updateRightTrackerList(rightTuple);
for (var tuple : leftCounterList) {
updateCounterFromRight(rightTuple, tuple, rightTrackerList);
}
}
}
@Override
public final void retractRight(UniTuple<Right_> rightTuple) {
ElementAwareListEntry<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-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/AbstractUnindexedJoinNode.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.LeftTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.RightTupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* 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 AbstractTuple, Right_, OutTuple_ extends AbstractTuple>
extends AbstractJoinNode<LeftTuple_, Right_, OutTuple_>
implements LeftTupleLifecycle<LeftTuple_>, RightTupleLifecycle<UniTuple<Right_>> {
private final int inputStoreIndexLeftEntry;
private final int inputStoreIndexRightEntry;
private final ElementAwareList<LeftTuple_> leftTupleList = new ElementAwareList<>();
private final ElementAwareList<UniTuple<Right_>> rightTupleList = new ElementAwareList<>();
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.");
}
var leftEntry = leftTupleList.add(leftTuple);
leftTuple.setStore(inputStoreIndexLeftEntry, leftEntry);
var outTupleListLeft = new ElementAwareList<OutTuple_>();
leftTuple.setStore(inputStoreIndexLeftOutTupleList, outTupleListLeft);
for (var tuple : rightTupleList) {
insertOutTupleFiltered(leftTuple, tuple);
}
}
@Override
public final void updateLeft(LeftTuple_ leftTuple) {
ElementAwareListEntry<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) {
ElementAwareListEntry<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;
}
ElementAwareList<OutTuple_> 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.");
}
var rightEntry = rightTupleList.add(rightTuple);
rightTuple.setStore(inputStoreIndexRightEntry, rightEntry);
var outTupleListRight = new ElementAwareList<OutTuple_>();
rightTuple.setStore(inputStoreIndexRightOutTupleList, outTupleListRight);
for (var tuple : leftTupleList) {
insertOutTupleFiltered(tuple, rightTuple);
}
}
@Override
public final void updateRight(UniTuple<Right_> rightTuple) {
ElementAwareListEntry<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) {
ElementAwareListEntry<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;
}
ElementAwareList<OutTuple_> outTupleListRight = rightTuple.removeStore(inputStoreIndexRightOutTupleList);
rightEntry.remove();
outTupleListRight.forEach(this::retractOutTuple);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/BavetAbstractConstraintStream.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.ArrayList;
import java.util.List;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintFactory;
import ai.timefold.solver.core.impl.score.stream.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.core.impl.score.stream.bavet.common.ConstraintNodeBuildHelper;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraintStream;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
import org.jspecify.annotations.NonNull;
public abstract class BavetAbstractConstraintStream<Solution_>
extends AbstractConstraintStream<Solution_>
implements BavetStream {
protected final BavetConstraintFactory<Solution_> constraintFactory;
protected final BavetAbstractConstraintStream<Solution_> parent;
protected final List<BavetAbstractConstraintStream<Solution_>> childStreamList = new ArrayList<>(2);
protected BavetAbstractConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(parent.getRetrievalSemantics());
this.constraintFactory = constraintFactory;
this.parent = parent;
}
protected BavetAbstractConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(retrievalSemantics);
this.constraintFactory = constraintFactory;
this.parent = null;
}
/**
* Whether the stream guarantees that no two tuples it produces will ever have the same set of facts.
* Streams which can prove that they either do or do not produce unique tuples should override this method.
*
* @return delegates to {@link #getParent()} if not null, otherwise false
*/
public boolean guaranteesDistinct() {
if (parent != null) {
// It is generally safe to take this from the parent; if the stream disagrees, it may override.
return parent.guaranteesDistinct();
} else { // Streams need to explicitly opt-in by overriding this method.
return false;
}
}
protected <Score_ extends Score<Score_>> Constraint buildConstraint(String constraintPackage, String constraintName,
String description, String constraintGroup, 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 constraintRef = ConstraintRef.of(resolvedConstraintPackage, constraintName);
var constraint = new BavetConstraint<>(constraintFactory, constraintRef, description, constraintGroup,
isConstraintWeightConfigurable ? null : constraintWeight, impactType, resolvedJustificationMapping,
resolvedIndictedObjectsMapping, stream);
stream.setConstraint(constraint);
return constraint;
}
public final <Stream_ extends BavetAbstractConstraintStream<Solution_>> Stream_ shareAndAddChild(Stream_ stream) {
return constraintFactory.share(stream, childStreamList::add);
}
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
if (parent == null) { // Maybe a join/ifExists/forEach forgot to override this?
throw new IllegalStateException("Impossible state: the stream (%s) does not have a parent."
.formatted(this));
}
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
/**
* Returns the stream which first produced the tuple that this stream operates on.
* If a stream does not have a single parent nor is it a source, it is expected to override this method.
*
* @return this if {@link TupleSource}, otherwise parent's tuple source.
*/
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
if (this instanceof TupleSource) {
return this;
} else if (parent == null) { // Maybe some stream forgot to override this?
throw new IllegalStateException("Impossible state: the stream (%s) does not have a parent."
.formatted(this));
}
return parent.getTupleSource();
}
public abstract <Score_ extends Score<Score_>> void buildNode(ConstraintNodeBuildHelper<Solution_, Score_> buildHelper);
protected void assertEmptyChildStreamList() {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException(
"Impossible state: the stream (%s) has a non-empty childStreamList (%s)."
.formatted(this, childStreamList));
}
}
@Override
public @NonNull BavetConstraintFactory<Solution_> getConstraintFactory() {
return constraintFactory;
}
/**
* @return null for join/ifExists nodes, which have left and right parents instead;
* also null for forEach node, which has no parent.
*/
@SuppressWarnings("unchecked")
@Override
public final BavetAbstractConstraintStream<Solution_> getParent() {
return parent;
}
public final List<BavetAbstractConstraintStream<Solution_>> getChildStreamList() {
return childStreamList;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/BavetStream.java | package ai.timefold.solver.core.impl.bavet.common;
public interface BavetStream {
<Stream_> Stream_ getParent();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/BavetStreamBinaryOperation.java | package ai.timefold.solver.core.impl.bavet.common;
public interface BavetStreamBinaryOperation<Stream_ extends BavetStream> {
Stream_ getLeftParent();
Stream_ getRightParent();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/DynamicPropagationQueue.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.ArrayList;
import java.util.BitSet;
import java.util.List;
import java.util.function.Consumer;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
/**
* This implementation has the capability to move tuples between the individual propagation queues.
* This is significantly less efficient than the {@link StaticPropagationQueue}.
*
* @param <Carrier_>
* @param <Tuple_>
*/
final class DynamicPropagationQueue<Tuple_ extends AbstractTuple, Carrier_ extends AbstractPropagationMetadataCarrier<Tuple_>>
implements PropagationQueue<Carrier_> {
private static final int INITIAL_CAPACITY = 1000; // Selected arbitrarily.
private final Consumer<Carrier_> preprocessor;
private final List<Carrier_> dirtyList;
private final BitSet retractQueue;
private final BitSet insertQueue;
private final TupleLifecycle<Tuple_> nextNodesTupleLifecycle;
private DynamicPropagationQueue(TupleLifecycle<Tuple_> nextNodesTupleLifecycle, Consumer<Carrier_> preprocessor,
int size) {
this.preprocessor = preprocessor;
/*
* All dirty carriers are stored in a list, never moved, never removed unless after propagation.
* Their unchanging position in the list is their index for the bitset-based queues.
* This way, we can cheaply move them between the queues.
*/
this.dirtyList = new ArrayList<>(size);
// Updates tend to be dominant; update queue isn't stored, it's deduced as neither insert nor retract.
this.retractQueue = new BitSet(size);
this.insertQueue = new BitSet(size);
this.nextNodesTupleLifecycle = nextNodesTupleLifecycle;
}
public DynamicPropagationQueue(TupleLifecycle<Tuple_> nextNodesTupleLifecycle) {
this(nextNodesTupleLifecycle, null, INITIAL_CAPACITY);
}
public DynamicPropagationQueue(TupleLifecycle<Tuple_> nextNodesTupleLifecycle, Consumer<Carrier_> preprocessor) {
this(nextNodesTupleLifecycle, preprocessor, INITIAL_CAPACITY);
}
@Override
public void insert(Carrier_ carrier) {
var positionInDirtyList = carrier.positionInDirtyList;
if (positionInDirtyList < 0) {
makeDirty(carrier, insertQueue);
} else {
switch (carrier.getState()) {
case UPDATING -> insertQueue.set(positionInDirtyList);
case ABORTING, DYING -> {
retractQueue.clear(positionInDirtyList);
insertQueue.set(positionInDirtyList);
}
default ->
throw new IllegalStateException("Impossible state: Cannot insert (%s), already inserting."
.formatted(carrier));
}
}
carrier.setState(TupleState.CREATING);
}
private void makeDirty(Carrier_ carrier, BitSet queue) {
dirtyList.add(carrier);
var position = dirtyList.size() - 1;
queue.set(position);
carrier.positionInDirtyList = position;
}
@Override
public void update(Carrier_ carrier) {
var positionInDirtyList = carrier.positionInDirtyList;
if (positionInDirtyList < 0) {
dirtyList.add(carrier);
carrier.positionInDirtyList = dirtyList.size() - 1;
} else {
switch (carrier.getState()) {
case CREATING -> insertQueue.clear(positionInDirtyList);
case ABORTING, DYING -> retractQueue.clear(positionInDirtyList);
default -> {
// Skip double updates.
}
}
}
carrier.setState(TupleState.UPDATING);
}
@Override
public void retract(Carrier_ carrier, TupleState state) {
if (state.isActive() || state == TupleState.DEAD) {
throw new IllegalArgumentException("Impossible state: The state (%s) is not a valid retract state."
.formatted(state));
}
var positionInDirtyList = carrier.positionInDirtyList;
if (positionInDirtyList < 0) {
makeDirty(carrier, retractQueue);
} else {
switch (carrier.getState()) {
case CREATING -> {
insertQueue.clear(positionInDirtyList);
retractQueue.set(positionInDirtyList);
}
case UPDATING -> retractQueue.set(positionInDirtyList);
default ->
throw new IllegalStateException("Impossible state: Cannot retract (%s), already retracting."
.formatted(carrier));
}
}
carrier.setState(state);
}
@Override
public void propagateRetracts() {
if (retractQueue.isEmpty()) {
return;
}
var i = retractQueue.nextSetBit(0);
while (i != -1) {
var carrier = dirtyList.get(i);
var state = carrier.getState();
switch (state) {
case DYING -> {
clean(carrier, TupleState.DEAD); // Hide original state from the next node by doing this before propagation.
nextNodesTupleLifecycle.retract(carrier.getTuple());
}
case ABORTING -> clean(carrier, TupleState.DEAD);
}
i = retractQueue.nextSetBit(i + 1);
}
}
private static void clean(AbstractPropagationMetadataCarrier<?> carrier, TupleState tupleState) {
carrier.setState(tupleState);
carrier.positionInDirtyList = -1;
}
@Override
public void propagateUpdates() {
var dirtyListSize = dirtyList.size();
var insertAndRetractQueue = buildInsertAndRetractQueue(insertQueue, retractQueue);
if (insertAndRetractQueue == null) { // Iterate over the entire list more efficiently.
for (var i = 0; i < dirtyListSize; i++) {
// Not using enhanced for loop in order not to create so many iterators in the hot path.
propagateInsertOrUpdate(dirtyList.get(i), true);
}
} else { // The gaps in the queue are the updates.
var i = insertAndRetractQueue.nextClearBit(0);
while (i != -1 && i < dirtyListSize) {
propagateInsertOrUpdate(dirtyList.get(i), true);
i = insertAndRetractQueue.nextClearBit(i + 1);
}
}
}
private static BitSet buildInsertAndRetractQueue(BitSet insertQueue, BitSet retractQueue) {
var noInserts = insertQueue.isEmpty();
var noRetracts = retractQueue.isEmpty();
if (noInserts && noRetracts) {
return null;
} else if (noInserts) {
return retractQueue;
} else if (noRetracts) {
return insertQueue;
} else {
var updateQueue = new BitSet(Math.max(insertQueue.length(), retractQueue.length()));
updateQueue.or(insertQueue);
updateQueue.or(retractQueue);
return updateQueue;
}
}
private void propagateInsertOrUpdate(Carrier_ carrier, boolean isUpdate) {
if (preprocessor != null) {
preprocessor.accept(carrier);
}
clean(carrier, TupleState.OK); // Hide original state from the next node by doing this before propagation.
if (isUpdate) {
nextNodesTupleLifecycle.update(carrier.getTuple());
} else {
nextNodesTupleLifecycle.insert(carrier.getTuple());
}
}
@Override
public void propagateInserts() {
if (!insertQueue.isEmpty()) {
var i = insertQueue.nextSetBit(0);
while (i != -1) {
propagateInsertOrUpdate(dirtyList.get(i), false);
i = insertQueue.nextSetBit(i + 1);
}
insertQueue.clear();
}
retractQueue.clear();
dirtyList.clear();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/ExistsCounter.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
public final class ExistsCounter<Tuple_ extends AbstractTuple>
extends AbstractPropagationMetadataCarrier<Tuple_> {
final Tuple_ leftTuple;
TupleState state = TupleState.DEAD; // It's the node's job to mark a new instance as CREATING.
int countRight = 0;
ExistsCounter(Tuple_ leftTuple) {
this.leftTuple = leftTuple;
}
@Override
public Tuple_ getTuple() {
return leftTuple;
}
@Override
public TupleState getState() {
return state;
}
@Override
public void setState(TupleState state) {
this.state = state;
}
@Override
public String toString() {
return "Counter(" + leftTuple + ")";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/Group.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
final class Group<OutTuple_ extends AbstractTuple, ResultContainer_>
extends AbstractPropagationMetadataCarrier<OutTuple_> {
public static <OutTuple_ extends AbstractTuple, ResultContainer_> Group<OutTuple_, ResultContainer_>
createWithoutAccumulate(Object groupKey, OutTuple_ outTuple) {
return new Group<>(groupKey, null, outTuple);
}
public static <OutTuple_ extends AbstractTuple, ResultContainer_> Group<OutTuple_, ResultContainer_>
createWithoutGroupKey(ResultContainer_ resultContainer, OutTuple_ outTuple) {
return new Group<>(null, resultContainer, outTuple);
}
public static <OutTuple_ extends AbstractTuple, ResultContainer_> Group<OutTuple_, ResultContainer_> create(Object groupKey,
ResultContainer_ resultContainer, OutTuple_ outTuple) {
return new Group<>(groupKey, resultContainer, outTuple);
}
private final Object groupKey;
private final ResultContainer_ resultContainer;
private final OutTuple_ outTuple;
public int parentCount = 1;
private Group(Object groupKey, ResultContainer_ resultContainer, OutTuple_ outTuple) {
this.groupKey = groupKey;
this.resultContainer = resultContainer;
this.outTuple = outTuple;
}
public Object getGroupKey() {
return groupKey;
}
public ResultContainer_ getResultContainer() {
return resultContainer;
}
@Override
public OutTuple_ getTuple() {
return outTuple;
}
@Override
public TupleState getState() {
return outTuple.state;
}
@Override
public void setState(TupleState state) {
outTuple.state = state;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/GroupNodeConstructor.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.List;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
import ai.timefold.solver.core.impl.util.Quadruple;
import ai.timefold.solver.core.impl.util.Triple;
public sealed interface GroupNodeConstructor<Tuple_ extends AbstractTuple>
permits AbstractGroupNodeConstructor {
// Although Tuple_ is unused in GroupNodeConstructor,
// it is used in its two implementations: GroupNodeConstructorWithAccumulate
// and GroupNodeConstructorWithoutAccumulate. The Tuple_ here serves as a type hint
// for the compiler, allowing it to correctly infer the types to use in the lambda
// being passed to GroupNodeConstructorWithAccumulate's and
// GroupNodeConstructorWithoutAccumulate's constructor.
// Each Group...Node with at least one collector have a constructor with the following signature:
// Group...Node(<keyMappings>, int groupStoreIndex, int undoStoreIndex, <collectors>,
// TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize,
// Environment environmentMode)
//
// The Group...Nodes with no collectors have a constructor with the following signature:
// Group...Node(<keyMappings>, int groupStoreIndex, TupleLifecycle<Tuple_> nextNodesTupleLifecycle,
// int outputStoreSize, Environment environmentMode)
//
// TupleLifecycle<Tuple_> in the constructor is the reason why having Tuple_ in the
// generic signature of this interface is useful.
//
// The interfaces in this file correspond to each of the possible signatures of the
// Group...Node constructor. These interfaces are thus covariant with a particular
// GroupXMappingYCollector...Node signature, allowing a method reference to be used.
// To reduce the number of interfaces, we use Collector..._ and Key..._ generics
// (instead of the classes UniConstraintCollector/Function, BiConstraintCollector/BiFunction, ...).
static <CollectorA_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
zeroKeysGroupBy(CollectorA_ collector, GroupBy0Mapping1CollectorNodeBuilder<CollectorA_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(collector,
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
groupStoreIndex, undoStoreIndex, collector, nextNodesTupleLifecycle, outputStoreSize,
environmentMode));
}
static <CollectorA_, CollectorB_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
zeroKeysGroupBy(CollectorA_ collectorA, CollectorB_ collectorB,
GroupBy0Mapping2CollectorNodeBuilder<CollectorA_, CollectorB_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(new Pair<>(collectorA, collectorB),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
groupStoreIndex, undoStoreIndex, collectorA, collectorB, nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <CollectorA_, CollectorB_, CollectorC_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
zeroKeysGroupBy(CollectorA_ collectorA, CollectorB_ collectorB, CollectorC_ collectorC,
GroupBy0Mapping3CollectorNodeBuilder<CollectorA_, CollectorB_, CollectorC_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(
new Triple<>(collectorA, collectorB, collectorC),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
groupStoreIndex, undoStoreIndex, collectorA, collectorB, collectorC,
nextNodesTupleLifecycle, outputStoreSize, environmentMode));
}
static <CollectorA_, CollectorB_, CollectorC_, CollectorD_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
zeroKeysGroupBy(CollectorA_ collectorA, CollectorB_ collectorB, CollectorC_ collectorC, CollectorD_ collectorD,
GroupBy0Mapping4CollectorNodeBuilder<CollectorA_, CollectorB_, CollectorC_, CollectorD_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(
new Quadruple<>(collectorA, collectorB, collectorC,
collectorD),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
groupStoreIndex, undoStoreIndex, collectorA, collectorB, collectorC, collectorD,
nextNodesTupleLifecycle, outputStoreSize, environmentMode));
}
static <KeyA_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
oneKeyGroupBy(KeyA_ keyMapping, GroupBy1Mapping0CollectorNodeBuilder<KeyA_, Tuple_> builder) {
return new GroupNodeConstructorWithoutAccumulate<>(keyMapping,
(groupStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(keyMapping,
groupStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode));
}
static <KeyA_, CollectorB_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
oneKeyGroupBy(KeyA_ keyMappingA, CollectorB_ collectorB,
GroupBy1Mapping1CollectorNodeBuilder<KeyA_, CollectorB_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(new Pair<>(keyMappingA, collectorB),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
keyMappingA, groupStoreIndex, undoStoreIndex, collectorB, nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <KeyA_, CollectorB_, CollectorC_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
oneKeyGroupBy(KeyA_ keyMappingA, CollectorB_ collectorB, CollectorC_ collectorC,
GroupBy1Mapping2CollectorNodeBuilder<KeyA_, CollectorB_, CollectorC_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(
new Triple<>(keyMappingA, collectorB, collectorC),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
keyMappingA, groupStoreIndex, undoStoreIndex, collectorB, collectorC,
nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <KeyA_, CollectorB_, CollectorC_, CollectorD_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
oneKeyGroupBy(KeyA_ keyMappingA, CollectorB_ collectorB, CollectorC_ collectorC, CollectorD_ collectorD,
GroupBy1Mapping3CollectorNodeBuilder<KeyA_, CollectorB_, CollectorC_, CollectorD_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(
new Quadruple<>(keyMappingA, collectorB, collectorC, collectorD),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
keyMappingA, groupStoreIndex, undoStoreIndex, collectorB, collectorC, collectorD,
nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <KeyA_, KeyB_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
twoKeysGroupBy(KeyA_ keyMappingA, KeyB_ keyMappingB,
GroupBy2Mapping0CollectorNodeBuilder<KeyA_, KeyB_, Tuple_> builder) {
return new GroupNodeConstructorWithoutAccumulate<>(new Pair<>(keyMappingA, keyMappingB),
(groupStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(keyMappingA,
keyMappingB, groupStoreIndex, nextNodesTupleLifecycle, outputStoreSize,
environmentMode));
}
static <KeyA_, KeyB_, CollectorC_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
twoKeysGroupBy(KeyA_ keyMappingA, KeyB_ keyMappingB, CollectorC_ collectorC,
GroupBy2Mapping1CollectorNodeBuilder<KeyA_, KeyB_, CollectorC_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(
new Triple<>(keyMappingA, keyMappingB, collectorC),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
keyMappingA, keyMappingB, groupStoreIndex, undoStoreIndex, collectorC,
nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <KeyA_, KeyB_, CollectorC_, CollectorD_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
twoKeysGroupBy(KeyA_ keyMappingA, KeyB_ keyMappingB, CollectorC_ collectorC, CollectorD_ collectorD,
GroupBy2Mapping2CollectorNodeBuilder<KeyA_, KeyB_, CollectorC_, CollectorD_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(
new Quadruple<>(keyMappingA, keyMappingB, collectorC, collectorD),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
keyMappingA, keyMappingB, groupStoreIndex, undoStoreIndex, collectorC, collectorD,
nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <KeyA_, KeyB_, KeyC_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
threeKeysGroupBy(KeyA_ keyMappingA, KeyB_ keyMappingB, KeyC_ keyMappingC,
GroupBy3Mapping0CollectorNodeBuilder<KeyA_, KeyB_, KeyC_, Tuple_> builder) {
return new GroupNodeConstructorWithoutAccumulate<>(
new Triple<>(keyMappingA, keyMappingB, keyMappingC),
(groupStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(keyMappingA,
keyMappingB, keyMappingC, groupStoreIndex, nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <KeyA_, KeyB_, KeyC_, CollectorD_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
threeKeysGroupBy(KeyA_ keyMappingA, KeyB_ keyMappingB, KeyC_ keyMappingC, CollectorD_ collectorD,
GroupBy3Mapping1CollectorNodeBuilder<KeyA_, KeyB_, KeyC_, CollectorD_, Tuple_> builder) {
return new GroupNodeConstructorWithAccumulate<>(
new Quadruple<>(keyMappingA, keyMappingB, keyMappingC, collectorD),
(groupStoreIndex, undoStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(
keyMappingA, keyMappingB, keyMappingC, groupStoreIndex, undoStoreIndex, collectorD,
nextNodesTupleLifecycle,
outputStoreSize, environmentMode));
}
static <KeyA_, KeyB_, KeyC_, KeyD_, Tuple_ extends AbstractTuple> GroupNodeConstructor<Tuple_>
fourKeysGroupBy(KeyA_ keyMappingA, KeyB_ keyMappingB, KeyC_ keyMappingC, KeyD_ keyMappingD,
GroupBy4Mapping0CollectorNodeBuilder<KeyA_, KeyB_, KeyC_, KeyD_, Tuple_> builder) {
return new GroupNodeConstructorWithoutAccumulate<>(
new Quadruple<>(keyMappingA, keyMappingB, keyMappingC, keyMappingD),
(groupStoreIndex, nextNodesTupleLifecycle, outputStoreSize, environmentMode) -> builder.build(keyMappingA,
keyMappingB, keyMappingC, keyMappingD, groupStoreIndex,
nextNodesTupleLifecycle, outputStoreSize, environmentMode));
}
@FunctionalInterface
interface NodeConstructorWithAccumulate<Tuple_ extends AbstractTuple> {
AbstractNode apply(int groupStoreIndex, int undoStoreIndex, TupleLifecycle<Tuple_> nextNodesTupleLifecycle,
int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface NodeConstructorWithoutAccumulate<Tuple_ extends AbstractTuple> {
AbstractNode apply(int groupStoreIndex, TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy0Mapping1CollectorNodeBuilder<CollectorA_, Tuple_ extends AbstractTuple> {
AbstractNode build(int groupStoreIndex, int undoStoreIndex,
CollectorA_ collector,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy0Mapping2CollectorNodeBuilder<CollectorA_, CollectorB_, Tuple_ extends AbstractTuple> {
AbstractNode build(int groupStoreIndex, int undoStoreIndex,
CollectorA_ collectorA,
CollectorB_ collectorB,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy0Mapping3CollectorNodeBuilder<CollectorA_, CollectorB_, CollectorC_, Tuple_ extends AbstractTuple> {
AbstractNode build(int groupStoreIndex, int undoStoreIndex,
CollectorA_ collectorA,
CollectorB_ collectorB,
CollectorC_ collectorC,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy0Mapping4CollectorNodeBuilder<CollectorA_, CollectorB_, CollectorC_, CollectorD_, Tuple_ extends AbstractTuple> {
AbstractNode build(int groupStoreIndex, int undoStoreIndex,
CollectorA_ collectorA,
CollectorB_ collectorB,
CollectorC_ collectorC,
CollectorD_ collectorD,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy1Mapping0CollectorNodeBuilder<KeyA_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMapping,
int groupStoreIndex,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy2Mapping0CollectorNodeBuilder<KeyA_, KeyB_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMappingA,
KeyB_ keyMappingB, int groupStoreIndex,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy3Mapping0CollectorNodeBuilder<KeyA_, KeyB_, KeyC_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMappingA,
KeyB_ keyMappingB,
KeyC_ keyMappingC,
int groupStoreIndex,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy4Mapping0CollectorNodeBuilder<KeyA_, KeyB_, KeyC_, KeyD_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMappingA,
KeyB_ keyMappingB,
KeyC_ keyMappingC,
KeyD_ keyMappingD,
int groupStoreIndex,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy1Mapping1CollectorNodeBuilder<KeyA_, CollectorB_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMapping,
int groupStoreIndex, int undoStoreIndex,
CollectorB_ collector,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy1Mapping2CollectorNodeBuilder<KeyA_, CollectorB_, CollectorC_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMapping,
int groupStoreIndex, int undoStoreIndex,
CollectorB_ collectorA,
CollectorC_ collectorB,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy1Mapping3CollectorNodeBuilder<KeyA_, CollectorB_, CollectorC_, CollectorD_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMapping,
int groupStoreIndex, int undoStoreIndex,
CollectorB_ collectorA,
CollectorC_ collectorB,
CollectorD_ collectorC,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy2Mapping1CollectorNodeBuilder<KeyA_, KeyB_, CollectorC_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMappingA,
KeyB_ keyMappingB, int groupStoreIndex, int undoStoreIndex,
CollectorC_ collectorC,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy2Mapping2CollectorNodeBuilder<KeyA_, KeyB_, CollectorC_, CollectorD_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMappingA,
KeyB_ keyMappingB,
int groupStoreIndex, int undoStoreIndex,
CollectorC_ collectorC,
CollectorD_ collectorD,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
@FunctionalInterface
interface GroupBy3Mapping1CollectorNodeBuilder<KeyA_, KeyB_, KeyC_, CollectorD_, Tuple_ extends AbstractTuple> {
AbstractNode build(KeyA_ keyMappingA,
KeyB_ keyMappingB,
KeyC_ keyMappingC,
int groupStoreIndex, int undoStoreIndex,
CollectorD_ collectorC,
TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode);
}
<Stream_ extends BavetStream> void build(AbstractNodeBuildHelper<Stream_> buildHelper, Stream_ parentTupleSource,
Stream_ aftStream, List<Stream_> aftStreamChildList, Stream_ thisStream, EnvironmentMode environmentMode);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/GroupNodeConstructorWithAccumulate.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.List;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
final class GroupNodeConstructorWithAccumulate<Tuple_ extends AbstractTuple> extends AbstractGroupNodeConstructor<Tuple_> {
private final NodeConstructorWithAccumulate<Tuple_> nodeConstructorFunction;
public GroupNodeConstructorWithAccumulate(Object equalityKey,
NodeConstructorWithAccumulate<Tuple_> nodeConstructorFunction) {
super(equalityKey);
this.nodeConstructorFunction = nodeConstructorFunction;
}
@Override
public <Stream_ extends BavetStream> void build(AbstractNodeBuildHelper<Stream_> buildHelper, Stream_ parentTupleSource,
Stream_ aftStream, List<Stream_> aftStreamChildList, Stream_ bridgeStream, EnvironmentMode environmentMode) {
var groupStoreIndex = buildHelper.reserveTupleStoreIndex(parentTupleSource);
var undoStoreIndex = buildHelper.reserveTupleStoreIndex(parentTupleSource);
TupleLifecycle<Tuple_> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(aftStreamChildList);
var outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = nodeConstructorFunction.apply(groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode);
buildHelper.addNode(node, bridgeStream);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/GroupNodeConstructorWithoutAccumulate.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.List;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
final class GroupNodeConstructorWithoutAccumulate<Tuple_ extends AbstractTuple> extends AbstractGroupNodeConstructor<Tuple_> {
private final NodeConstructorWithoutAccumulate<Tuple_> nodeConstructorFunction;
public GroupNodeConstructorWithoutAccumulate(Object equalityKey,
NodeConstructorWithoutAccumulate<Tuple_> nodeConstructorFunction) {
super(equalityKey);
this.nodeConstructorFunction = nodeConstructorFunction;
}
@Override
public <Stream_ extends BavetStream> void build(AbstractNodeBuildHelper<Stream_> buildHelper, Stream_ parentTupleSource,
Stream_ aftStream, List<Stream_> aftStreamChildList, Stream_ bridgeStream, EnvironmentMode environmentMode) {
var groupStoreIndex = buildHelper.reserveTupleStoreIndex(parentTupleSource);
TupleLifecycle<Tuple_> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(aftStreamChildList);
var outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = nodeConstructorFunction.apply(groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode);
buildHelper.addNode(node, bridgeStream);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/PropagationQueue.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
/**
* A propagation queue is an ordered collection of items that need to be sent to the next node.
* This operation is called propagation.
* <p>
* In order to properly update joins, removing stale data before joining is required.
* To that end, retracts need to be propagated first, then updates and finally inserts.
* Other than that, the order of propagation is the order of insertion into the queue.
* <p>
* Once an item propagates, it is set to a stable state that indicates it has been propagated,
* either {@link TupleState#OK} or {@link TupleState#DEAD}.
* Subsequent nodes will only see their input tuples in these states.
* <p>
* The propagation operation consists of three phases:
* <ol>
* <li>Retracts: {@link #propagateRetracts()}</li>
* <li>Updates: {@link #propagateUpdates()}</li>
* <li>Inserts: {@link #propagateInserts()}</li>
* </ol>
* All of them need to be called, and in this order.
* Otherwise, the queue will be in an inconsistent state,
* likely resulting in runtime exceptions and/or score corruption.
* <p>
* The reason why these operations are not combined into a single method is the fact
* that multiple nodes may need to execute their retracts first,
* and only when all of those are propagated, the rest of the phases can start.
*
* @see Propagator Even more information about propagation.
* @param <T>
*/
public sealed interface PropagationQueue<T>
extends Propagator
permits DynamicPropagationQueue, StaticPropagationQueue {
void insert(T item);
void update(T item);
void retract(T item, TupleState state);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/Propagator.java | package ai.timefold.solver.core.impl.bavet.common;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraintSession;
/**
* Propagator is an interface that exposes the {@link PropagationQueue} to {@link BavetConstraintSession}.
* It does not include the methods for inserting/updating/retracting facts,
* as the session accesses them via the {@link AbstractNode}.
* <p>
* Nodes come in layers, and each layer has {@link AbstractNode#getLayerIndex() a unique index}.
* Nodes in higher layers receive their inputs from nodes in lower layers.
* Propagation starts from the lowest layer ({@code 0}) and goes up.
* Layer N+1 only starts propagating after layer N has completed its propagation,
* that is after {@link #propagateRetracts()},
* {@link #propagateUpdates()} and {@link #propagateInserts()} have been called on every node in the layer.
* This happens in and is guaranteed by {@link BavetConstraintSession#calculateScore()}.
* <p>
* Nodes in a layer do not propagate entirely independently.
* In fact, we first call {@link #propagateRetracts()} on all nodes in the layer,
* then {@link #propagateUpdates()} and finally {@link #propagateInserts()}.
* This order of operations is necessary to ensure consistent data in the higher layer nodes.
* <p>
* Example: consider a join node that joins two different classes of facts, say A and B.
* The join node has two inputs, one for each type of fact.
* Both of these inputs are in the same layer, say layer 1.
* This puts the join node in layer 2.
* If we had the left input propagate updates and inserts before the right input propagates retracts,
* a situation could occur where the left input is attempting to join with something that will later be retracted.
* And this, in turn, could result in a runtime exception,
* because the right input data at that point is stale.
* By running retracts on all nodes in a layer first, and then all updates and then all inserts,
* we make sure that the join node always has up-to-date data.
* And due to the fact that propagation is done in layers,
* the join propagations will only ever be triggered after its inputs have completed their propagation.
* <p>
* As this is critical to the correctness of Bavet,
* there is specific test coverage for these corner cases.
*
* @see PropagationQueue More information about propagation.
*/
public sealed interface Propagator permits PropagationQueue {
/**
* Starts the propagation event. Must be followed by {@link #propagateUpdates()}.
*/
void propagateRetracts();
/**
* Must be preceded by {@link #propagateRetracts()} and followed by {@link #propagateInserts()}.
*/
void propagateUpdates();
/**
* Must by preceded by {@link #propagateRetracts()} and {@link #propagateUpdates()}.
* Ends the propagation event and clears the queue.
*/
void propagateInserts();
/**
* Convenience method for cases where the node layer only contains a single node,
* and therefore it can be propagated all at once.
*/
default void propagateEverything() {
propagateRetracts();
propagateUpdates();
propagateInserts();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/StaticPropagationQueue.java | package ai.timefold.solver.core.impl.bavet.common;
import java.util.ArrayDeque;
import java.util.Deque;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
/**
* The implementation moves tuples directly into an either retract, update or insert queue,
* without any option of moving between the queues.
* This is the most efficient implementation.
* It will throw exceptions if a tuple is in the wrong queue, based on its state.
*
* @param <Tuple_>
*/
public final class StaticPropagationQueue<Tuple_ extends AbstractTuple>
implements PropagationQueue<Tuple_> {
private final Deque<Tuple_> retractQueue;
private final Deque<Tuple_> updateQueue;
private final Deque<Tuple_> insertQueue;
private final TupleLifecycle<Tuple_> nextNodesTupleLifecycle;
public StaticPropagationQueue(TupleLifecycle<Tuple_> nextNodesTupleLifecycle, int size) {
// Guesstimate that updates are dominant.
this.retractQueue = new ArrayDeque<>(size / 20);
this.updateQueue = new ArrayDeque<>((size / 20) * 18);
this.insertQueue = new ArrayDeque<>(size / 20);
this.nextNodesTupleLifecycle = nextNodesTupleLifecycle;
}
public StaticPropagationQueue(TupleLifecycle<Tuple_> nextNodesTupleLifecycle) {
this(nextNodesTupleLifecycle, 1000);
}
@Override
public void insert(Tuple_ carrier) {
if (carrier.state == TupleState.CREATING) {
throw new IllegalStateException("Impossible state: The tuple (%s) is already in the insert queue."
.formatted(carrier));
}
carrier.state = TupleState.CREATING;
insertQueue.add(carrier);
}
@Override
public void update(Tuple_ carrier) {
if (carrier.state == TupleState.UPDATING) { // Skip double updates.
return;
}
carrier.state = TupleState.UPDATING;
updateQueue.add(carrier);
}
@Override
public void retract(Tuple_ carrier, TupleState state) {
var carrierState = carrier.state;
if (carrierState == state) { // Skip double retracts.
return;
}
if (state.isActive() || state == TupleState.DEAD) {
throw new IllegalArgumentException("Impossible state: The state (%s) is not a valid retract state."
.formatted(state));
} else if (carrierState == TupleState.ABORTING || carrierState == TupleState.DYING) {
throw new IllegalStateException("Impossible state: The tuple (%s) is already in the retract queue."
.formatted(carrier));
}
carrier.state = state;
retractQueue.add(carrier);
}
@Override
public void propagateRetracts() {
if (retractQueue.isEmpty()) {
return;
}
for (var tuple : retractQueue) {
switch (tuple.state) {
case DYING -> {
// Change state before propagation, so that the next node can't make decisions on the original state.
tuple.state = TupleState.DEAD;
nextNodesTupleLifecycle.retract(tuple);
}
case ABORTING -> tuple.state = TupleState.DEAD;
}
}
retractQueue.clear();
}
@Override
public void propagateUpdates() {
processAndClear(updateQueue);
}
private void processAndClear(Deque<Tuple_> dirtyQueue) {
if (dirtyQueue.isEmpty()) {
return;
}
for (var tuple : dirtyQueue) {
if (tuple.state == TupleState.DEAD) {
/*
* DEAD signifies the tuple was both in insert/update and retract queues.
* This happens when a tuple was inserted/updated and subsequently retracted, all before propagation.
* We can safely ignore the later insert/update,
* as by this point the more recent retract has already been processed,
* setting the state to DEAD.
*/
continue;
}
// Change state before propagation, so that the next node can't make decisions on the original state.
tuple.state = TupleState.OK;
if (dirtyQueue == updateQueue) {
nextNodesTupleLifecycle.update(tuple);
} else {
nextNodesTupleLifecycle.insert(tuple);
}
}
dirtyQueue.clear();
}
@Override
public void propagateInserts() {
processAndClear(insertQueue);
if (!retractQueue.isEmpty()) {
throw new IllegalStateException("Impossible state: The retract queue (%s) is not empty."
.formatted(retractQueue));
} else if (!updateQueue.isEmpty()) {
throw new IllegalStateException("Impossible state: The update queue (%s) is not empty."
.formatted(updateQueue));
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/TupleSource.java | package ai.timefold.solver.core.impl.bavet.common;
public interface TupleSource {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/package-info.java | /**
* This package contains performance-sensitive code.
* Much of it is directly on the hot path of the solver.
* It contains various micro-optimizations, the benefits of which have been confirmed by extensive benchmarking.
* When it comes to this code, assumptions and pre-conceived notions of JVM performance should not be trusted.
* Instead, any likely performance-altering modifications to this code should be carefully benchmarked.
*/
package ai.timefold.solver.core.impl.bavet.common; |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/ComparisonIndexer.java | package ai.timefold.solver.core.impl.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.core.impl.bavet.common.joiner.JoinerType;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
final class ComparisonIndexer<T, Key_ extends Comparable<Key_>>
implements Indexer<T> {
private final KeyRetriever<Key_> keyRetriever;
private final Supplier<Indexer<T>> downstreamIndexerSupplier;
private final Comparator<Key_> keyComparator;
private final boolean hasOrEquals;
private final NavigableMap<Key_, Indexer<T>> comparisonMap;
/**
* Construct an {@link ComparisonIndexer} which immediately ends in a {@link NoneIndexer}.
* This means {@code indexKeys} must be a single key.
*
* @param comparisonJoinerType the type of comparison to use
*/
public ComparisonIndexer(JoinerType comparisonJoinerType) {
this(comparisonJoinerType, new SingleKeyRetriever<>(), NoneIndexer::new);
}
/**
* Construct an {@link ComparisonIndexer} which does not immediately go to a {@link NoneIndexer}.
* This means {@code indexKeys} must be an instance of {@link IndexKeys}.
*
* @param comparisonJoinerType the type of comparison to use
* @param keyIndex the index of the key to use within {@link IndexKeys}.
* @param downstreamIndexerSupplier the supplier of the downstream indexer
*/
public ComparisonIndexer(JoinerType comparisonJoinerType, int keyIndex, Supplier<Indexer<T>> downstreamIndexerSupplier) {
this(comparisonJoinerType, new ManyKeyRetriever<>(keyIndex), downstreamIndexerSupplier);
}
private ComparisonIndexer(JoinerType comparisonJoinerType, KeyRetriever<Key_> keyRetriever,
Supplier<Indexer<T>> downstreamIndexerSupplier) {
this.keyRetriever = Objects.requireNonNull(keyRetriever);
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)
? Comparator.<Key_> naturalOrder().reversed()
: Comparator.naturalOrder();
this.hasOrEquals = comparisonJoinerType == JoinerType.GREATER_THAN_OR_EQUAL
|| comparisonJoinerType == JoinerType.LESS_THAN_OR_EQUAL;
this.comparisonMap = new TreeMap<>(keyComparator);
}
@Override
public ElementAwareListEntry<T> put(Object indexKeys, T tuple) {
Key_ indexKey = keyRetriever.apply(indexKeys);
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
var downstreamIndexer = comparisonMap.get(indexKey);
if (downstreamIndexer == null) {
downstreamIndexer = downstreamIndexerSupplier.get();
comparisonMap.put(indexKey, downstreamIndexer);
}
return downstreamIndexer.put(indexKeys, tuple);
}
@Override
public void remove(Object indexKeys, ElementAwareListEntry<T> entry) {
Key_ indexKey = keyRetriever.apply(indexKeys);
var downstreamIndexer = getDownstreamIndexer(indexKeys, indexKey, entry);
downstreamIndexer.remove(indexKeys, entry);
if (downstreamIndexer.isEmpty()) {
comparisonMap.remove(indexKey);
}
}
private Indexer<T> getDownstreamIndexer(Object indexKeys, Key_ indexerKey, ElementAwareListEntry<T> entry) {
var downstreamIndexer = comparisonMap.get(indexerKey);
if (downstreamIndexer == null) {
throw new IllegalStateException(
"Impossible state: the tuple (%s) with indexKeys (%s) doesn't exist in the indexer %s."
.formatted(entry.getElement(), indexKeys, this));
}
return downstreamIndexer;
}
// TODO clean up DRY
@Override
public int size(Object indexKeys) {
var mapSize = comparisonMap.size();
if (mapSize == 0) {
return 0;
}
Key_ indexKey = keyRetriever.apply(indexKeys);
if (mapSize == 1) { // Avoid creation of the entry set and iterator.
var entry = comparisonMap.firstEntry();
var 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(indexKeys);
} else {
var size = 0;
for (var entry : comparisonMap.entrySet()) {
var 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(indexKeys);
}
return size;
}
}
@Override
public void forEach(Object indexKeys, Consumer<T> tupleConsumer) {
var size = comparisonMap.size();
if (size == 0) {
return;
}
Key_ indexKey = keyRetriever.apply(indexKeys);
if (size == 1) { // Avoid creation of the entry set and iterator.
var entry = comparisonMap.firstEntry();
visitEntry(indexKeys, tupleConsumer, indexKey, entry);
} else {
for (var entry : comparisonMap.entrySet()) {
var boundaryReached = visitEntry(indexKeys, tupleConsumer, indexKey, entry);
if (boundaryReached) {
return;
}
}
}
}
private boolean visitEntry(Object indexKeys, 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.
var 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(indexKeys, tupleConsumer);
return false;
}
@Override
public boolean isEmpty() {
return comparisonMap.isEmpty();
}
@Override
public String toString() {
return "size = " + comparisonMap.size();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/EqualsIndexer.java | package ai.timefold.solver.core.impl.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.core.impl.util.ElementAwareListEntry;
final class EqualsIndexer<T, Key_> implements Indexer<T> {
private final KeyRetriever<Key_> keyRetriever;
private final Supplier<Indexer<T>> downstreamIndexerSupplier;
private final Map<Key_, Indexer<T>> downstreamIndexerMap = new HashMap<>();
/**
* Construct an {@link EqualsIndexer} which immediately ends in a {@link NoneIndexer}.
* This means {@code indexKeys} must be a single key.
*/
public EqualsIndexer() {
this.keyRetriever = new SingleKeyRetriever<>();
this.downstreamIndexerSupplier = NoneIndexer::new;
}
/**
* Construct an {@link EqualsIndexer} which does not immediately go to a {@link NoneIndexer}.
* This means {@code indexKeys} must be an instance of {@link IndexKeys}.
*
* @param keyIndex the index of the key to use within {@link IndexKeys}.
* @param downstreamIndexerSupplier the supplier of the downstream indexer
*/
public EqualsIndexer(int keyIndex, Supplier<Indexer<T>> downstreamIndexerSupplier) {
this.keyRetriever = new ManyKeyRetriever<>(keyIndex);
this.downstreamIndexerSupplier = Objects.requireNonNull(downstreamIndexerSupplier);
}
@Override
public ElementAwareListEntry<T> put(Object indexKeys, T tuple) {
Key_ indexKey = keyRetriever.apply(indexKeys);
// 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(indexKeys, tuple);
}
@Override
public void remove(Object indexKeys, ElementAwareListEntry<T> entry) {
Key_ indexKey = keyRetriever.apply(indexKeys);
Indexer<T> downstreamIndexer = getDownstreamIndexer(indexKeys, indexKey, entry);
downstreamIndexer.remove(indexKeys, entry);
if (downstreamIndexer.isEmpty()) {
downstreamIndexerMap.remove(indexKey);
}
}
private Indexer<T> getDownstreamIndexer(Object indexKeys, Key_ indexerKey, ElementAwareListEntry<T> entry) {
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexerKey);
if (downstreamIndexer == null) {
throw new IllegalStateException(
"Impossible state: the tuple (%s) with indexKey (%s) doesn't exist in the indexer %s."
.formatted(entry.getElement(), indexKeys, this));
}
return downstreamIndexer;
}
@Override
public int size(Object indexKeys) {
Key_ indexKey = keyRetriever.apply(indexKeys);
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null) {
return 0;
}
return downstreamIndexer.size(indexKeys);
}
@Override
public void forEach(Object indexKeys, Consumer<T> tupleConsumer) {
Key_ indexKey = keyRetriever.apply(indexKeys);
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null) {
return;
}
downstreamIndexer.forEach(indexKeys, tupleConsumer);
}
@Override
public boolean isEmpty() {
return downstreamIndexerMap.isEmpty();
}
@Override
public String toString() {
return "size = " + downstreamIndexerMap.size();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/IndexKeys.java | package ai.timefold.solver.core.impl.bavet.common.index;
/**
* Cached in tuples; each tuple carries its unique instance.
* <p>
* Instances are shallow immutable and implement {@link Object#equals(Object)} and {@link Object#hashCode()}.
* If two instances contain elements which are equal, they must be equal.
* <p>
* Instances should be obtained using {@link IndexKeys#none()},
* {@link IndexKeys#of(Object)},
* {@link IndexKeys#of(Object, Object)}
* or {@link IndexKeys#ofMany(Object[])}.
* <p>
* This interface only has two implementations,
* giving the JVM simple bi-morphic call sites.
* There is no {@code NoIndexKeys}, as that is handled by {@link #none()}.
* There is also no {@code SingleIndexKeys}, see {@link #of(Object)} for rationale.
* {@link TwoIndexKeys} exists to avoid wrapping two keys with an entire array,
* with the use case of two keys still being relatively common.
* ThreeIndexKeys and higher are sufficiently rare for {@link ManyIndexKeys} to suffice.
*/
public sealed interface IndexKeys
permits ManyIndexKeys, TwoIndexKeys {
static IndexKeys none() {
return ManyIndexKeys.EMPTY;
}
/**
* @param key may be null, typically in cases where the indexed property is a nullable planning variable.
* @return When the key is not {@code null}, returns the key itself,
* as opposed to some wrapping instance of {@link IndexKeys}.
* Wrapping is not necessary in this case,
* as the wrapper would do nothing but delegate {@link Object#equals(Object)} and {@link Object#hashCode()}
* to the wrapped key anyway.
* Avoiding the wrapper saves considerable memory and gets rid of a level of indirection.
*/
static Object of(Object key) {
return key == null ? ManyIndexKeys.SINGLE_NULL : key;
}
static <Key1_, Key2_> IndexKeys of(Key1_ key1, Key2_ key2) {
return new TwoIndexKeys<>(key1, key2);
}
static IndexKeys ofMany(Object... keys) {
return new ManyIndexKeys(keys);
}
/**
* Retrieves key at a given position.
*
* @param id Maps to a single {@link Indexer} instance in the indexer chain.
* @return May be null if the key is null.
* @param <Key_> {@link ComparisonIndexer} will expect this to implement {@link Comparable}.
* {@link EqualsIndexer} will treat items as the same if they are equal.
*/
<Key_> Key_ get(int id);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/Indexer.java | package ai.timefold.solver.core.impl.bavet.common.index;
import java.util.function.Consumer;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* An indexer for entity or fact {@code X},
* maps a property or a combination of properties of {@code X}, denoted by {@code indexKeys},
* 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 TupleState} is needed by clients of
* {@link #forEach(Object, 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 sealed interface Indexer<T> permits ComparisonIndexer, EqualsIndexer, NoneIndexer {
ElementAwareListEntry<T> put(Object indexKeys, T tuple);
void remove(Object indexKeys, ElementAwareListEntry<T> entry);
int size(Object indexKeys);
void forEach(Object indexKeys, Consumer<T> tupleConsumer);
boolean isEmpty();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/IndexerFactory.java | package ai.timefold.solver.core.impl.bavet.common.index;
import java.util.ArrayList;
import java.util.List;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.bi.joiner.DefaultBiJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.AbstractJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.JoinerType;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.bavet.penta.joiner.DefaultPentaJoiner;
import ai.timefold.solver.core.impl.bavet.quad.joiner.DefaultQuadJoiner;
import ai.timefold.solver.core.impl.bavet.tri.joiner.DefaultTriJoiner;
import ai.timefold.solver.core.impl.util.Pair;
import ai.timefold.solver.core.impl.util.Quadruple;
import ai.timefold.solver.core.impl.util.Triple;
/**
* {@link Indexer Indexers} form a parent-child hierarchy,
* each child has exactly one parent.
* {@link 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 {@link NoneIndexer}.
* <p>
* Example 1: EQUAL+LESS_THAN joiner will become EqualsIndexer -> ComparisonIndexer -> NoneIndexer.
* <p>
* Indexers have an id, which is the position of the indexer in the chain.
* Top-most indexer has id 0, and the id increases as we go down the hierarchy.
* Each {@link AbstractTuple tuple} is assigned an
* {@link IndexKeys} instance,
* which determines its location in the index.
* {@link IndexKeys} instances are built from
* {@link AbstractJoiner joiners}
* using methods such as {@link #buildUniLeftKeysExtractor()} and {@link #buildRightKeysExtractor()}.
* Each {@link IndexKeys#get(int) index keyFunction} has an
* id,
* and this id matches the id of the indexer;
* each keyFunction in {@link IndexKeys} is associated with a
* single indexer.
* <p>
* Comparison joiners result in a single indexer each,
* whereas equal joiners will be merged into a single indexer if they are consecutive.
* In the latter case,
* a composite keyFunction is created of type {@link Pair}, {@link TriTuple},
* {@link Quadruple} or {@link IndexerKey},
* based on the length of the composite keyFunction (number of equals joiners in sequence).
*
* <ul>
* <li>Example 2: For an EQUAL+LESS_THAN joiner,
* there are two indexers in the chain with keyFunction length of 1 each.</li>
* <li>Example 3: For an LESS_THAN+EQUAL+EQUAL joiner,
* there are still two indexers,
* but the second indexer's keyFunction length is 2.</li>
* <li>Example 4: For an LESS_THAN+EQUAL+EQUAL+LESS_THAN joiner,
* there are three indexers in the chain,
* and the middle one's keyFunction length is 2.</li>
* </ul>
*
* @param <Right_>
*/
public final class IndexerFactory<Right_> {
private final AbstractJoiner<Right_> joiner;
private final NavigableMap<Integer, JoinerType> joinerTypeMap;
public IndexerFactory(AbstractJoiner<Right_> joiner) {
this.joiner = joiner;
var joinerCount = joiner.getJoinerCount();
if (joinerCount < 2) {
joinerTypeMap = null;
} else {
joinerTypeMap = new TreeMap<>();
for (var i = 1; i <= joinerCount; i++) {
var joinerType = i < joinerCount ? joiner.getJoinerType(i) : null;
var previousJoinerType = joiner.getJoinerType(i - 1);
if (joinerType != JoinerType.EQUAL || previousJoinerType != joinerType) {
/*
* Equal joiner is building a composite key with preceding equal joiner(s).
* Does not apply to joiners other than equal; for those, each indexer has its own simple key.
*/
joinerTypeMap.put(i, previousJoinerType);
}
}
}
}
public boolean hasJoiners() {
return joiner.getJoinerCount() > 0;
}
public <A> UniKeysExtractor<A> buildUniLeftKeysExtractor() {
var castJoiner = (DefaultBiJoiner<A, Right_>) joiner;
return buildUniKeysExtractor(castJoiner::getLeftMapping);
}
@SuppressWarnings("unchecked")
private <A> UniKeysExtractor<A> buildUniKeysExtractor(IntFunction<Function<A, Object>> mappingExtractor) {
var joinerCount = joiner.getJoinerCount();
if (joinerCount == 0) {
return tuple -> IndexKeys.none();
} else if (joinerCount == 1) {
return toKeysExtractor(mappingExtractor.apply(0));
}
var startIndexInclusive = 0;
var keyFunctionList = new ArrayList<Function<A, Object>>();
for (var entry : joinerTypeMap.entrySet()) {
var endIndexExclusive = entry.getKey();
var keyFunctionLength = endIndexExclusive - startIndexInclusive;
// Consecutive EQUAL joiners are merged into a single composite keyFunction.
Function<A, Object> keyFunction = switch (keyFunctionLength) {
case 1 -> mappingExtractor.apply(startIndexInclusive);
case 2 -> {
var mapping1 = mappingExtractor.apply(startIndexInclusive);
var mapping2 = mappingExtractor.apply(startIndexInclusive + 1);
yield a -> new Pair<>(mapping1.apply(a), mapping2.apply(a));
}
case 3 -> {
var mapping1 = mappingExtractor.apply(startIndexInclusive);
var mapping2 = mappingExtractor.apply(startIndexInclusive + 1);
var mapping3 = mappingExtractor.apply(startIndexInclusive + 2);
yield a -> new Triple<>(mapping1.apply(a), mapping2.apply(a), mapping3.apply(a));
}
case 4 -> {
var mapping1 = mappingExtractor.apply(startIndexInclusive);
var mapping2 = mappingExtractor.apply(startIndexInclusive + 1);
var mapping3 = mappingExtractor.apply(startIndexInclusive + 2);
var mapping4 = mappingExtractor.apply(startIndexInclusive + 3);
yield a -> new Quadruple<>(mapping1.apply(a), mapping2.apply(a), mapping3.apply(a),
mapping4.apply(a));
}
default -> {
Function<A, Object>[] mappings = new Function[joinerCount];
for (var i = 0; i < joinerCount; i++) {
var mapping = mappingExtractor.apply(i);
mappings[i] = mapping;
}
yield toCompositeKeyFunction(mappings);
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
return toKeysExtractor(keyFunctionList);
}
@SafeVarargs
private static <A> Function<A, Object> toCompositeKeyFunction(Function<A, Object>... mappings) {
return a -> {
var mappingCount = mappings.length;
var result = new Object[mappingCount];
for (var i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a);
}
return new IndexerKey(result);
};
}
private static <A> UniKeysExtractor<A> toKeysExtractor(Function<A, Object> keyFunction) {
return tuple -> {
var a = tuple.factA;
return IndexKeys.of(keyFunction.apply(a));
};
}
private static <A> UniKeysExtractor<A> toKeysExtractor(List<Function<A, Object>> keyFunctionList) {
var keyFunctionCount = keyFunctionList.size();
return switch (keyFunctionCount) {
case 1 -> toKeysExtractor(keyFunctionList.get(0));
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield tuple -> {
var a = tuple.factA;
return IndexKeys.of(keyFunction1.apply(a), keyFunction2.apply(a));
};
}
default -> tuple -> {
var a = tuple.factA;
var arr = new Object[keyFunctionCount];
for (var i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a);
}
return IndexKeys.ofMany(arr);
};
};
}
@SuppressWarnings("unchecked")
public <A, B> BiKeysExtractor<A, B> buildBiLeftKeysExtractor() {
var joinerCount = joiner.getJoinerCount();
var castJoiner = (DefaultTriJoiner<A, B, Right_>) joiner;
if (joinerCount == 0) {
return tuple -> IndexKeys.none();
} else if (joinerCount == 1) {
return toKeysExtractor(castJoiner.getLeftMapping(0));
}
var startIndexInclusive = 0;
var keyFunctionList = new ArrayList<BiFunction<A, B, Object>>();
for (var entry : joinerTypeMap.entrySet()) {
var endIndexExclusive = entry.getKey();
var keyFunctionLength = endIndexExclusive - startIndexInclusive;
// Consecutive EQUAL joiners are merged into a single composite keyFunction.
BiFunction<A, B, Object> keyFunction = switch (keyFunctionLength) {
case 1 -> castJoiner.getLeftMapping(startIndexInclusive);
case 2 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
yield (a, b) -> new Pair<>(mapping1.apply(a, b), mapping2.apply(a, b));
}
case 3 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
var mapping3 = castJoiner.getLeftMapping(startIndexInclusive + 2);
yield (a, b) -> new Triple<>(mapping1.apply(a, b), mapping2.apply(a, b), mapping3.apply(a, b));
}
case 4 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
var mapping3 = castJoiner.getLeftMapping(startIndexInclusive + 2);
var mapping4 = castJoiner.getLeftMapping(startIndexInclusive + 3);
yield (a, b) -> new Quadruple<>(mapping1.apply(a, b), mapping2.apply(a, b), mapping3.apply(a, b),
mapping4.apply(a, b));
}
default -> {
BiFunction<A, B, Object>[] mappings = new BiFunction[joinerCount];
for (var i = 0; i < joinerCount; i++) {
var mapping = castJoiner.getLeftMapping(i);
mappings[i] = mapping;
}
yield (a, b) -> {
var mappingCount = mappings.length;
var result = new Object[mappingCount];
for (var i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a, b);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
var keyFunctionCount = keyFunctionList.size();
return switch (keyFunctionCount) {
case 1 -> toKeysExtractor(keyFunctionList.get(0));
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield tuple -> {
var a = tuple.factA;
var b = tuple.factB;
return IndexKeys.of(keyFunction1.apply(a, b), keyFunction2.apply(a, b));
};
}
default -> tuple -> {
var a = tuple.factA;
var b = tuple.factB;
var arr = new Object[keyFunctionCount];
for (var i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a, b);
}
return IndexKeys.ofMany(arr);
};
};
}
private static <A, B> BiKeysExtractor<A, B> toKeysExtractor(BiFunction<A, B, Object> keyFunction) {
return tuple -> {
var a = tuple.factA;
var b = tuple.factB;
return IndexKeys.of(keyFunction.apply(a, b));
};
}
@SuppressWarnings("unchecked")
public <A, B, C> TriKeysExtractor<A, B, C> buildTriLeftKeysExtractor() {
var joinerCount = joiner.getJoinerCount();
var castJoiner = (DefaultQuadJoiner<A, B, C, Right_>) joiner;
if (joinerCount == 0) {
return tuple -> IndexKeys.none();
} else if (joinerCount == 1) {
return toKeysExtractor(castJoiner.getLeftMapping(0));
}
var startIndexInclusive = 0;
var keyFunctionList = new ArrayList<TriFunction<A, B, C, Object>>();
for (var entry : joinerTypeMap.entrySet()) {
var endIndexExclusive = entry.getKey();
var keyFunctionLength = endIndexExclusive - startIndexInclusive;
// Consecutive EQUAL joiners are merged into a single composite keyFunction.
TriFunction<A, B, C, Object> keyFunction = switch (keyFunctionLength) {
case 1 -> castJoiner.getLeftMapping(startIndexInclusive);
case 2 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
yield (a, b, c) -> new Pair<>(mapping1.apply(a, b, c), mapping2.apply(a, b, c));
}
case 3 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
var mapping3 = castJoiner.getLeftMapping(startIndexInclusive + 2);
yield (a, b, c) -> new Triple<>(mapping1.apply(a, b, c), mapping2.apply(a, b, c),
mapping3.apply(a, b, c));
}
case 4 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
var mapping3 = castJoiner.getLeftMapping(startIndexInclusive + 2);
var mapping4 = castJoiner.getLeftMapping(startIndexInclusive + 3);
yield (a, b, c) -> new Quadruple<>(mapping1.apply(a, b, c), mapping2.apply(a, b, c),
mapping3.apply(a, b, c), mapping4.apply(a, b, c));
}
default -> {
TriFunction<A, B, C, Object>[] mappings = new TriFunction[joinerCount];
for (var i = 0; i < joinerCount; i++) {
var mapping = castJoiner.getLeftMapping(i);
mappings[i] = mapping;
}
yield (a, b, c) -> {
var mappingCount = mappings.length;
var result = new Object[mappingCount];
for (var i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a, b, c);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
var keyFunctionCount = keyFunctionList.size();
return switch (keyFunctionCount) {
case 1 -> toKeysExtractor(keyFunctionList.get(0));
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield tuple -> {
var a = tuple.factA;
var b = tuple.factB;
var c = tuple.factC;
return IndexKeys.of(keyFunction1.apply(a, b, c), keyFunction2.apply(a, b, c));
};
}
default -> tuple -> {
var a = tuple.factA;
var b = tuple.factB;
var c = tuple.factC;
var arr = new Object[keyFunctionCount];
for (var i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a, b, c);
}
return IndexKeys.ofMany(arr);
};
};
}
private static <A, B, C> TriKeysExtractor<A, B, C> toKeysExtractor(TriFunction<A, B, C, Object> keyFunction) {
return tuple -> {
var a = tuple.factA;
var b = tuple.factB;
var c = tuple.factC;
return IndexKeys.of(keyFunction.apply(a, b, c));
};
}
@SuppressWarnings("unchecked")
public <A, B, C, D> QuadKeysExtractor<A, B, C, D> buildQuadLeftKeysExtractor() {
var joinerCount = joiner.getJoinerCount();
var castJoiner = (DefaultPentaJoiner<A, B, C, D, Right_>) joiner;
if (joinerCount == 0) {
return tuple -> IndexKeys.none();
} else if (joinerCount == 1) {
return toKeysExtractor(castJoiner.getLeftMapping(0));
}
var startIndexInclusive = 0;
var keyFunctionList = new ArrayList<QuadFunction<A, B, C, D, Object>>();
for (var entry : joinerTypeMap.entrySet()) {
var endIndexExclusive = entry.getKey();
var keyFunctionLength = endIndexExclusive - startIndexInclusive;
// Consecutive EQUAL joiners are merged into a single composite keyFunction.
QuadFunction<A, B, C, D, Object> keyFunction = switch (keyFunctionLength) {
case 1 -> castJoiner.getLeftMapping(startIndexInclusive);
case 2 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
yield (a, b, c, d) -> new Pair<>(mapping1.apply(a, b, c, d), mapping2.apply(a, b, c, d));
}
case 3 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
var mapping3 = castJoiner.getLeftMapping(startIndexInclusive + 2);
yield (a, b, c, d) -> new Triple<>(mapping1.apply(a, b, c, d), mapping2.apply(a, b, c, d),
mapping3.apply(a, b, c, d));
}
case 4 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
var mapping3 = castJoiner.getLeftMapping(startIndexInclusive + 2);
var mapping4 = castJoiner.getLeftMapping(startIndexInclusive + 3);
yield (a, b, c, d) -> new Quadruple<>(mapping1.apply(a, b, c, d), mapping2.apply(a, b, c, d),
mapping3.apply(a, b, c, d), mapping4.apply(a, b, c, d));
}
default -> {
QuadFunction<A, B, C, D, Object>[] mappings = new QuadFunction[joinerCount];
for (var i = 0; i < joinerCount; i++) {
var mapping = castJoiner.getLeftMapping(i);
mappings[i] = mapping;
}
yield (a, b, c, d) -> {
var mappingCount = mappings.length;
var result = new Object[mappingCount];
for (var i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a, b, c, d);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
var keyFunctionCount = keyFunctionList.size();
return switch (keyFunctionList.size()) {
case 1 -> toKeysExtractor(keyFunctionList.get(0));
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield tuple -> {
var a = tuple.factA;
var b = tuple.factB;
var c = tuple.factC;
var d = tuple.factD;
return IndexKeys.of(keyFunction1.apply(a, b, c, d), keyFunction2.apply(a, b, c, d));
};
}
default -> tuple -> {
var a = tuple.factA;
var b = tuple.factB;
var c = tuple.factC;
var d = tuple.factD;
var arr = new Object[keyFunctionCount];
for (var i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a, b, c, d);
}
return IndexKeys.ofMany(arr);
};
};
}
private static <A, B, C, D> QuadKeysExtractor<A, B, C, D> toKeysExtractor(QuadFunction<A, B, C, D, Object> keyFunction) {
return tuple -> {
var a = tuple.factA;
var b = tuple.factB;
var c = tuple.factC;
var d = tuple.factD;
return IndexKeys.of(keyFunction.apply(a, b, c, d));
};
}
public UniKeysExtractor<Right_> buildRightKeysExtractor() {
return buildUniKeysExtractor(joiner::getRightMapping);
}
public <T> Indexer<T> buildIndexer(boolean isLeftBridge) {
/*
* Note that if creating indexer for a right bridge node, the joiner type has to be flipped.
* (<A, B> becomes <B, A>.)
*/
if (!hasJoiners()) { // NoneJoiner results in NoneIndexer.
return new NoneIndexer<>();
} else if (joiner.getJoinerCount() == 1) { // Single joiner maps directly to EqualsIndexer or ComparisonIndexer.
var joinerType = joiner.getJoinerType(0);
if (joinerType == JoinerType.EQUAL) {
return new EqualsIndexer<>();
} else {
return new ComparisonIndexer<>(isLeftBridge ? joinerType : joinerType.flip());
}
}
// The following code builds the children first, so it needs to iterate over the joiners in reverse order.
var descendingJoinerTypeMap = joinerTypeMap.descendingMap();
Supplier<Indexer<T>> noneIndexerSupplier = NoneIndexer::new;
Supplier<Indexer<T>> downstreamIndexerSupplier = noneIndexerSupplier;
var indexPropertyId = descendingJoinerTypeMap.size() - 1;
for (var entry : descendingJoinerTypeMap.entrySet()) {
var joinerType = entry.getValue();
if (downstreamIndexerSupplier == noneIndexerSupplier && indexPropertyId == 0) {
if (joinerType == JoinerType.EQUAL) {
downstreamIndexerSupplier = EqualsIndexer::new;
} else {
var actualJoinerType = isLeftBridge ? joinerType : joinerType.flip();
downstreamIndexerSupplier = () -> new ComparisonIndexer<>(actualJoinerType);
}
} else {
var actualDownstreamIndexerSupplier = downstreamIndexerSupplier;
var effectivelyFinalIndexPropertyId = indexPropertyId;
if (joinerType == JoinerType.EQUAL) {
downstreamIndexerSupplier =
() -> new EqualsIndexer<>(effectivelyFinalIndexPropertyId, actualDownstreamIndexerSupplier);
} else {
var actualJoinerType = isLeftBridge ? joinerType : joinerType.flip();
downstreamIndexerSupplier = () -> new ComparisonIndexer<>(actualJoinerType, effectivelyFinalIndexPropertyId,
actualDownstreamIndexerSupplier);
}
}
indexPropertyId--;
}
return downstreamIndexerSupplier.get();
}
/**
* Represents a function which extracts index keys from a tuple.
*
* @param <Tuple_>
*/
@FunctionalInterface
public interface KeysExtractor<Tuple_ extends AbstractTuple> extends Function<Tuple_, Object> {
}
@FunctionalInterface
public interface UniKeysExtractor<A> extends KeysExtractor<UniTuple<A>> {
}
@FunctionalInterface
public interface BiKeysExtractor<A, B> extends KeysExtractor<BiTuple<A, B>> {
}
@FunctionalInterface
public interface TriKeysExtractor<A, B, C> extends KeysExtractor<TriTuple<A, B, C>> {
}
@FunctionalInterface
public interface QuadKeysExtractor<A, B, C, D> extends KeysExtractor<QuadTuple<A, B, C, D>> {
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/IndexerKey.java | package ai.timefold.solver.core.impl.bavet.common.index;
import java.util.Arrays;
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}, ...
* Overrides {@link Object#equals(Object)} and {@link Object#hashCode()} as it references external object.
*/
record IndexerKey(Object... properties) {
@Override
public boolean equals(Object o) {
if (o instanceof IndexerKey other) {
return Arrays.deepEquals(properties, other.properties);
}
return false;
}
@Override
public int hashCode() {
return Arrays.deepHashCode(properties);
}
@Override
public String toString() {
return Arrays.toString(properties);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/KeyRetriever.java | package ai.timefold.solver.core.impl.bavet.common.index;
import java.util.function.Function;
sealed interface KeyRetriever<Key_> extends Function<Object, Key_>
permits ManyKeyRetriever, SingleKeyRetriever {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/ManyIndexKeys.java | package ai.timefold.solver.core.impl.bavet.common.index;
import java.util.Arrays;
record ManyIndexKeys(Object... properties) implements IndexKeys {
static final ManyIndexKeys EMPTY = new ManyIndexKeys();
static final ManyIndexKeys SINGLE_NULL = new ManyIndexKeys((Object) null);
@SuppressWarnings("unchecked")
@Override
public <Key_> Key_ get(int id) {
return (Key_) properties[id];
}
@Override
public boolean equals(Object o) {
if (this == o) { // Due to the use of SINGLE_NULL, this is possible.
return true;
}
return o instanceof ManyIndexKeys other && 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-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/ManyKeyRetriever.java | package ai.timefold.solver.core.impl.bavet.common.index;
record ManyKeyRetriever<Key_>(int id) implements KeyRetriever<Key_> {
@Override
public Key_ apply(Object indexKeys) {
return ((IndexKeys) indexKeys).get(id);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/NoneIndexer.java | package ai.timefold.solver.core.impl.bavet.common.index;
import java.util.function.Consumer;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
public final class NoneIndexer<T> implements Indexer<T> {
private final ElementAwareList<T> tupleList = new ElementAwareList<>();
@Override
public ElementAwareListEntry<T> put(Object indexKeys, T tuple) {
return tupleList.add(tuple);
}
@Override
public void remove(Object indexKeys, ElementAwareListEntry<T> entry) {
entry.remove();
}
@Override
public int size(Object indexKeys) {
return tupleList.size();
}
@Override
public void forEach(Object indexKeys, 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-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/SingleKeyRetriever.java | package ai.timefold.solver.core.impl.bavet.common.index;
record SingleKeyRetriever<Key_>() implements KeyRetriever<Key_> {
@SuppressWarnings("unchecked")
@Override
public Key_ apply(Object indexKeys) {
return (Key_) indexKeys;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/TwoIndexKeys.java | package ai.timefold.solver.core.impl.bavet.common.index;
record TwoIndexKeys<A, B>(A propertyA, B propertyB) implements IndexKeys {
@SuppressWarnings("unchecked")
@Override
public <Key_> Key_ get(int id) {
return (Key_) switch (id) {
case 0 -> propertyA;
case 1 -> propertyB;
default -> throw new IllegalArgumentException("Impossible state: index (%d) > 1"
.formatted(id));
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/index/package-info.java | /**
* This package contains code that deals with indexing of tuples.
* The entry point is {@link ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory},
* which also contains a description of the entire mechanism.
*/
package ai.timefold.solver.core.impl.bavet.common.index; |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/joiner/AbstractJoiner.java | package ai.timefold.solver.core.impl.bavet.common.joiner;
import java.util.Objects;
import java.util.function.Function;
public abstract class AbstractJoiner<Right_> {
protected final Function<Right_, Object>[] rightMappings;
protected final JoinerType[] joinerTypes;
protected <Property_> AbstractJoiner(Function<Right_, Property_> rightMapping, JoinerType joinerType) {
this(new Function[] { rightMapping }, new JoinerType[] { joinerType });
}
protected <Property_> AbstractJoiner(Function<Right_, Property_>[] rightMappings, JoinerType[] joinerTypes) {
this.rightMappings = (Function<Right_, Object>[]) Objects.requireNonNull(rightMappings);
this.joinerTypes = Objects.requireNonNull(joinerTypes);
}
public final Function<Right_, Object> getRightMapping(int index) {
return rightMappings[index];
}
public final int getJoinerCount() {
return joinerTypes.length;
}
public final JoinerType getJoinerType(int index) {
return joinerTypes[index];
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/joiner/JoinerType.java | package ai.timefold.solver.core.impl.bavet.common.joiner;
import java.util.Collection;
import java.util.Objects;
import java.util.function.BiPredicate;
public enum JoinerType {
EQUAL(Objects::equals),
LESS_THAN((a, b) -> ((Comparable) a).compareTo(b) < 0),
LESS_THAN_OR_EQUAL((a, b) -> ((Comparable) a).compareTo(b) <= 0),
GREATER_THAN((a, b) -> ((Comparable) a).compareTo(b) > 0),
GREATER_THAN_OR_EQUAL((a, b) -> ((Comparable) a).compareTo(b) >= 0),
CONTAINING((a, b) -> ((Collection) a).contains(b)),
INTERSECTING((a, b) -> intersecting((Collection) a, (Collection) b)),
DISJOINT((a, b) -> disjoint((Collection) a, (Collection) b));
private final BiPredicate<Object, Object> matcher;
JoinerType(BiPredicate<Object, Object> matcher) {
this.matcher = matcher;
}
public JoinerType flip() {
switch (this) {
case LESS_THAN:
return GREATER_THAN;
case LESS_THAN_OR_EQUAL:
return GREATER_THAN_OR_EQUAL;
case GREATER_THAN:
return LESS_THAN;
case GREATER_THAN_OR_EQUAL:
return LESS_THAN_OR_EQUAL;
default:
throw new IllegalStateException("The joinerType (" + this + ") cannot be flipped.");
}
}
public boolean matches(Object left, Object right) {
try {
return matcher.test(left, right);
} catch (Exception e) { // For easier debugging, in the absence of pointing to a specific constraint.
throw new IllegalStateException(
"Joiner (" + this + ") threw an exception matching left (" + left + ") and right (" + right + ") objects.",
e);
}
}
private static boolean disjoint(Collection<?> leftCollection, Collection<?> rightCollection) {
return leftCollection.stream().noneMatch(rightCollection::contains) &&
rightCollection.stream().noneMatch(leftCollection::contains);
}
private static boolean intersecting(Collection<?> leftCollection, Collection<?> rightCollection) {
return leftCollection.stream().anyMatch(rightCollection::contains) ||
rightCollection.stream().anyMatch(leftCollection::contains);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/AbstractTuple.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
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.
*
* <p>
* A tuple is modifiable.
* However, only the origin node of a tuple (the node where the tuple is the out tuple) may modify it.
*/
public abstract sealed class AbstractTuple permits UniTuple, BiTuple, TriTuple, QuadTuple {
private static final Object[] EMPTY_STORE = new Object[0];
private final Object[] store;
public TupleState state = TupleState.DEAD; // It's the node's job to mark a new tuple as CREATING.
protected AbstractTuple(int storeSize) {
this.store = storeSize == 0 ? EMPTY_STORE : new Object[storeSize];
}
public final <Value_> Value_ getStore(int index) {
return (Value_) store[index];
}
public final void setStore(int index, Object value) {
store[index] = value;
}
public final <Value_> Value_ removeStore(int index) {
Value_ value = getStore(index);
setStore(index, null);
return value;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/AggregatedTupleLifecycle.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
import java.util.Arrays;
import java.util.Objects;
record AggregatedTupleLifecycle<Tuple_ extends AbstractTuple>(TupleLifecycle<Tuple_>... lifecycles)
implements
TupleLifecycle<Tuple_> {
@SafeVarargs
public AggregatedTupleLifecycle {
// Exists so that we have something to put the @SafeVarargs annotation on.
}
@Override
public void insert(Tuple_ tuple) {
for (var lifecycle : lifecycles) {
lifecycle.insert(tuple);
}
}
@Override
public void update(Tuple_ tuple) {
for (var lifecycle : lifecycles) {
lifecycle.update(tuple);
}
}
@Override
public void retract(Tuple_ tuple) {
for (var lifecycle : lifecycles) {
lifecycle.retract(tuple);
}
}
@Override
public boolean equals(Object o) {
return o instanceof AggregatedTupleLifecycle<?> that &&
Objects.deepEquals(lifecycles, that.lifecycles);
}
@Override
public int hashCode() {
return Arrays.hashCode(lifecycles);
}
@Override
public String toString() {
return "size = " + lifecycles.length;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/BiTuple.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
public final class BiTuple<A, B> extends AbstractTuple {
// Only a tuple's origin node may modify a fact.
public A factA;
public B factB;
public BiTuple(A factA, B factB, int storeSize) {
super(storeSize);
this.factA = factA;
this.factB = factB;
}
@Override
public String toString() {
return "{" + factA + ", " + factB + "}";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/ConditionalTupleLifecycle.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
import java.util.Objects;
import java.util.function.Predicate;
public record ConditionalTupleLifecycle<Tuple_ extends AbstractTuple>(TupleLifecycle<Tuple_> downstreamLifecycle,
TuplePredicate<Tuple_> predicate)
implements
TupleLifecycle<Tuple_> {
public ConditionalTupleLifecycle {
Objects.requireNonNull(downstreamLifecycle);
Objects.requireNonNull(predicate);
}
@Override
public void insert(Tuple_ tuple) {
if (predicate.test(tuple)) {
downstreamLifecycle.insert(tuple);
}
}
@Override
public void update(Tuple_ tuple) {
if (predicate.test(tuple)) {
downstreamLifecycle.update(tuple);
} else {
downstreamLifecycle.retract(tuple);
}
}
@Override
public void retract(Tuple_ tuple) {
downstreamLifecycle.retract(tuple);
}
@Override
public String toString() {
return "Conditional %s".formatted(downstreamLifecycle);
}
@FunctionalInterface
interface TuplePredicate<Tuple_ extends AbstractTuple> extends Predicate<Tuple_> {
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/LeftTupleLifecycle.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
public interface LeftTupleLifecycle<Tuple_ extends AbstractTuple> {
void insertLeft(Tuple_ tuple);
void updateLeft(Tuple_ tuple);
void retractLeft(Tuple_ tuple);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/LeftTupleLifecycleImpl.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
import java.util.Objects;
record LeftTupleLifecycleImpl<Tuple_ extends AbstractTuple>(LeftTupleLifecycle<Tuple_> leftTupleLifecycle)
implements
TupleLifecycle<Tuple_> {
LeftTupleLifecycleImpl {
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-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/QuadTuple.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
public final class QuadTuple<A, B, C, D> extends AbstractTuple {
// Only a tuple's origin node may modify a fact.
public A factA;
public B factB;
public C factC;
public D factD;
public QuadTuple(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 String toString() {
return "{" + factA + ", " + factB + ", " + factC + ", " + factD + "}";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/RightTupleLifecycle.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
public interface RightTupleLifecycle<Tuple_ extends AbstractTuple> {
void insertRight(Tuple_ tuple);
void updateRight(Tuple_ tuple);
void retractRight(Tuple_ tuple);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/RightTupleLifecycleImpl.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
import java.util.Objects;
record RightTupleLifecycleImpl<Tuple_ extends AbstractTuple>(RightTupleLifecycle<Tuple_> rightTupleLifecycle)
implements
TupleLifecycle<Tuple_> {
RightTupleLifecycleImpl {
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-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/TriTuple.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
public final class TriTuple<A, B, C> extends AbstractTuple {
// Only a tuple's origin node may modify a fact.
public A factA;
public B factB;
public C factC;
public TriTuple(A factA, B factB, C factC, int storeSize) {
super(storeSize);
this.factA = factA;
this.factB = factB;
this.factC = factC;
}
@Override
public String toString() {
return "{" + factA + ", " + factB + ", " + factC + "}";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/TupleLifecycle.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
import java.util.Arrays;
import java.util.Objects;
import java.util.function.BiPredicate;
import java.util.function.Predicate;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.function.TriPredicate;
public interface TupleLifecycle<Tuple_ extends AbstractTuple> {
static <Tuple_ extends AbstractTuple> TupleLifecycle<Tuple_> ofLeft(LeftTupleLifecycle<Tuple_> leftTupleLifecycle) {
return new LeftTupleLifecycleImpl<>(leftTupleLifecycle);
}
static <Tuple_ extends AbstractTuple> TupleLifecycle<Tuple_> ofRight(RightTupleLifecycle<Tuple_> rightTupleLifecycle) {
return new RightTupleLifecycleImpl<>(rightTupleLifecycle);
}
@SuppressWarnings({ "rawtypes", "unchecked" })
@SafeVarargs
static <Tuple_ extends AbstractTuple> TupleLifecycle<Tuple_> aggregate(TupleLifecycle<Tuple_>... tupleLifecycles) {
var distinctTupleLifecycles = Arrays.stream(Objects.requireNonNull(tupleLifecycles))
.distinct()
.toArray(TupleLifecycle[]::new);
return switch (distinctTupleLifecycles.length) {
case 0 -> throw new IllegalStateException("Impossible state: there are no tuple lifecycles.");
case 1 -> distinctTupleLifecycles[0];
default -> new AggregatedTupleLifecycle<>(distinctTupleLifecycles);
};
}
static <A> TupleLifecycle<UniTuple<A>> conditionally(TupleLifecycle<UniTuple<A>> tupleLifecycle, Predicate<A> predicate) {
return new ConditionalTupleLifecycle<>(tupleLifecycle, tuple -> predicate.test(tuple.factA));
}
static <A, B> TupleLifecycle<BiTuple<A, B>> conditionally(TupleLifecycle<BiTuple<A, B>> tupleLifecycle,
BiPredicate<A, B> predicate) {
return new ConditionalTupleLifecycle<>(tupleLifecycle, tuple -> predicate.test(tuple.factA, tuple.factB));
}
static <A, B, C> TupleLifecycle<TriTuple<A, B, C>> conditionally(TupleLifecycle<TriTuple<A, B, C>> tupleLifecycle,
TriPredicate<A, B, C> predicate) {
return new ConditionalTupleLifecycle<>(tupleLifecycle, tuple -> predicate.test(tuple.factA, tuple.factB, tuple.factC));
}
static <A, B, C, D> TupleLifecycle<QuadTuple<A, B, C, D>>
conditionally(TupleLifecycle<QuadTuple<A, B, C, D>> tupleLifecycle, QuadPredicate<A, B, C, D> predicate) {
return new ConditionalTupleLifecycle<>(tupleLifecycle,
tuple -> predicate.test(tuple.factA, tuple.factB, tuple.factC, tuple.factD));
}
void insert(Tuple_ tuple);
void update(Tuple_ tuple);
void retract(Tuple_ tuple);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/TupleState.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
public enum TupleState {
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;
TupleState(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-core/1.26.1/ai/timefold/solver/core/impl/bavet/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/common/tuple/UniTuple.java | package ai.timefold.solver.core.impl.bavet.common.tuple;
public final class UniTuple<A> extends AbstractTuple {
// Only a tuple's origin node may modify a fact.
public A factA;
public UniTuple(A factA, int storeSize) {
super(storeSize);
this.factA = factA;
}
@Override
public String toString() {
return "{" + factA + "}";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/penta | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/penta/joiner/DefaultPentaJoiner.java | package ai.timefold.solver.core.impl.bavet.penta.joiner;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.AbstractJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.JoinerType;
import org.jspecify.annotations.NonNull;
public final class DefaultPentaJoiner<A, B, C, D, E> extends AbstractJoiner<E> implements PentaJoiner<A, B, C, D, E> {
private static final DefaultPentaJoiner NONE =
new DefaultPentaJoiner(new QuadFunction[0], new JoinerType[0], new Function[0]);
private final QuadFunction<A, B, C, D, ?>[] leftMappings;
public <Property_> DefaultPentaJoiner(QuadFunction<A, B, C, D, Property_> leftMapping, JoinerType joinerType,
Function<E, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new QuadFunction[] { leftMapping };
}
private <Property_> DefaultPentaJoiner(QuadFunction<A, B, C, D, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<E, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C, D, E> DefaultPentaJoiner<A, B, C, D, E> merge(List<DefaultPentaJoiner<A, B, C, D, E>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultPentaJoiner::and);
}
@Override
public @NonNull DefaultPentaJoiner<A, B, C, D, E> and(@NonNull PentaJoiner<A, B, C, D, E> otherJoiner) {
DefaultPentaJoiner<A, B, C, D, E> castJoiner = (DefaultPentaJoiner<A, B, C, D, E>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
QuadFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoinerCount; i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultPentaJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public QuadFunction<A, B, C, D, Object> getLeftMapping(int index) {
return (QuadFunction<A, B, C, D, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c, D d, E e) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b, c, d);
Object rightMapping = getRightMapping(i).apply(e);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (o instanceof DefaultPentaJoiner<?, ?, ?, ?, ?> other) {
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/penta | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/penta/joiner/FilteringPentaJoiner.java | package ai.timefold.solver.core.impl.bavet.penta.joiner;
import java.util.Objects;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import org.jspecify.annotations.NonNull;
public final class FilteringPentaJoiner<A, B, C, D, E> implements PentaJoiner<A, B, C, D, E> {
private final PentaPredicate<A, B, C, D, E> filter;
public FilteringPentaJoiner(PentaPredicate<A, B, C, D, E> filter) {
this.filter = filter;
}
@Override
public @NonNull FilteringPentaJoiner<A, B, C, D, E> and(@NonNull PentaJoiner<A, B, C, D, E> otherJoiner) {
FilteringPentaJoiner<A, B, C, D, E> castJoiner = (FilteringPentaJoiner<A, B, C, D, E>) otherJoiner;
return new FilteringPentaJoiner<>(filter.and(castJoiner.getFilter()));
}
public PentaPredicate<A, B, C, D, E> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof FilteringPentaJoiner)) {
return false;
}
FilteringPentaJoiner<?, ?, ?, ?, ?> other = (FilteringPentaJoiner<?, ?, ?, ?, ?>) o;
return Objects.equals(filter, other.filter);
}
@Override
public int hashCode() {
return Objects.hash(filter);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/penta | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/penta/joiner/PentaJoinerComber.java | package ai.timefold.solver.core.impl.bavet.penta.joiner;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
/**
* Combs an array of {@link PentaJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
* @param <C>
* @param <D>
* @param <E>
*/
public final class PentaJoinerComber<A, B, C, D, E> {
public static <A, B, C, D, E> PentaJoinerComber<A, B, C, D, E> comb(PentaJoiner<A, B, C, D, E>[] joiners) {
List<DefaultPentaJoiner<A, B, C, D, E>> defaultJoinerList = new ArrayList<>(joiners.length);
List<PentaPredicate<A, B, C, D, E>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
PentaJoiner<A, B, C, D, E> joiner = joiners[i];
if (joiner instanceof FilteringPentaJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringPentaJoiner<A, B, C, D, E>) joiner).getFilter());
} else if (joiner instanceof DefaultPentaJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultPentaJoiner<A, B, C, D, E>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultPentaJoiner<A, B, C, D, E> mergedJoiner = DefaultPentaJoiner.merge(defaultJoinerList);
PentaPredicate<A, B, C, D, E> mergedFiltering = mergeFiltering(filteringList);
return new PentaJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <A, B, C, D, E> PentaPredicate<A, B, C, D, E>
mergeFiltering(List<PentaPredicate<A, B, C, D, E>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c, D d, E e) -> {
for (PentaPredicate<A, B, C, D, E> predicate : filteringList) {
if (!predicate.test(a, b, c, d, e)) {
return false;
}
}
return true;
};
}
}
private final DefaultPentaJoiner<A, B, C, D, E> mergedJoiner;
private final PentaPredicate<A, B, C, D, E> mergedFiltering;
public PentaJoinerComber(DefaultPentaJoiner<A, B, C, D, E> mergedJoiner, PentaPredicate<A, B, C, D, E> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultPentaJoiner<A, B, C, D, E> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public PentaPredicate<A, B, C, D, E> getMergedFiltering() {
return mergedFiltering;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/AbstractGroupQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.function.Function;
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;
import ai.timefold.solver.core.impl.bavet.common.AbstractGroupNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
abstract class AbstractGroupQuadNode<OldA, OldB, OldC, OldD, OutTuple_ extends AbstractTuple, GroupKey_, ResultContainer_, Result_>
extends AbstractGroupNode<QuadTuple<OldA, OldB, OldC, OldD>, OutTuple_, 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.factA, tuple.factB, tuple.factC, tuple.factD);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/ConcatBiQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.function.BiFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatBiQuadNode<A, B, C, D>
extends AbstractConcatNode<BiTuple<A, B>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
private final BiFunction<A, B, C> paddingFunctionC;
private final BiFunction<A, B, D> paddingFunctionD;
public ConcatBiQuadNode(BiFunction<A, B, C> paddingFunctionC, BiFunction<A, B, D> paddingFunctionD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromLeft(BiTuple<A, B> leftTuple) {
var factA = leftTuple.factA;
var factB = leftTuple.factB;
return new QuadTuple<>(factA, factB,
paddingFunctionC.apply(factA, factB), paddingFunctionD.apply(factA, factB),
outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple) {
return new QuadTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, rightTuple.factD, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(BiTuple<A, B> leftTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
}
@Override
protected void updateOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
outTuple.factD = rightTuple.factD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/ConcatQuadBiNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.function.BiFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatQuadBiNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, BiTuple<A, B>, QuadTuple<A, B, C, D>> {
private final BiFunction<A, B, C> paddingFunctionC;
private final BiFunction<A, B, D> paddingFunctionD;
public ConcatQuadBiNode(BiFunction<A, B, C> paddingFunctionC, BiFunction<A, B, D> paddingFunctionD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD, outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromRight(BiTuple<A, B> rightTuple) {
var factA = rightTuple.factA;
var factB = rightTuple.factB;
return new QuadTuple<>(factA, factB,
paddingFunctionC.apply(factA, factB), paddingFunctionD.apply(factA, factB),
outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
outTuple.factD = leftTuple.factD;
}
@Override
protected void updateOutTupleFromRight(BiTuple<A, B> rightTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/ConcatQuadQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatQuadQuadNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
public ConcatQuadQuadNode(TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD, outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple) {
return new QuadTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, rightTuple.factD, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
outTuple.factD = leftTuple.factD;
}
@Override
protected void updateOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
outTuple.factD = rightTuple.factD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/ConcatQuadTriNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatQuadTriNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, TriTuple<A, B, C>, QuadTuple<A, B, C, D>> {
private final TriFunction<A, B, C, D> paddingFunction;
public ConcatQuadTriNode(TriFunction<A, B, C, D> paddingFunction,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunction = paddingFunction;
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD, outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromRight(TriTuple<A, B, C> rightTuple) {
var factA = rightTuple.factA;
var factB = rightTuple.factB;
var factC = rightTuple.factC;
return new QuadTuple<>(factA, factB, factC,
paddingFunction.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
outTuple.factD = leftTuple.factD;
}
@Override
protected void updateOutTupleFromRight(TriTuple<A, B, C> rightTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/ConcatQuadUniNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class ConcatQuadUniNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, UniTuple<A>, QuadTuple<A, B, C, D>> {
private final Function<A, B> paddingFunctionB;
private final Function<A, C> paddingFunctionC;
private final Function<A, D> paddingFunctionD;
public ConcatQuadUniNode(Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC, Function<A, D> paddingFunctionD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD, outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromRight(UniTuple<A> rightTuple) {
var factA = rightTuple.factA;
return new QuadTuple<>(factA,
paddingFunctionB.apply(factA), paddingFunctionC.apply(factA), paddingFunctionD.apply(factA),
outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(QuadTuple<A, B, C, D> leftTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
outTuple.factD = leftTuple.factD;
}
@Override
protected void updateOutTupleFromRight(UniTuple<A> rightTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = rightTuple.factA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/ConcatTriQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatTriQuadNode<A, B, C, D>
extends AbstractConcatNode<TriTuple<A, B, C>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
private final TriFunction<A, B, C, D> paddingFunction;
public ConcatTriQuadNode(TriFunction<A, B, C, D> paddingFunction,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunction = paddingFunction;
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromLeft(TriTuple<A, B, C> leftTuple) {
var factA = leftTuple.factA;
var factB = leftTuple.factB;
var factC = leftTuple.factC;
return new QuadTuple<>(factA, factB, factC,
paddingFunction.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple) {
return new QuadTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, rightTuple.factD, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(TriTuple<A, B, C> leftTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void updateOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
outTuple.factD = rightTuple.factD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/ConcatUniQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class ConcatUniQuadNode<A, B, C, D>
extends AbstractConcatNode<UniTuple<A>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
private final Function<A, B> paddingFunctionB;
private final Function<A, C> paddingFunctionC;
private final Function<A, D> paddingFunctionD;
public ConcatUniQuadNode(Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC, Function<A, D> paddingFunctionD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList,
outputStoreSize);
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
this.paddingFunctionD = paddingFunctionD;
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromLeft(UniTuple<A> leftTuple) {
var factA = leftTuple.factA;
return new QuadTuple<>(factA,
paddingFunctionB.apply(factA), paddingFunctionC.apply(factA), paddingFunctionD.apply(factA),
outputStoreSize);
}
@Override
protected QuadTuple<A, B, C, D> getOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple) {
return new QuadTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, rightTuple.factD, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(UniTuple<A> leftTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = leftTuple.factA;
}
@Override
protected void updateOutTupleFromRight(QuadTuple<A, B, C, D> rightTuple, QuadTuple<A, B, C, D> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
outTuple.factD = rightTuple.factD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/FlattenLastQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public 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;
public 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 QuadTuple<>(originalTuple.factA, originalTuple.factB, originalTuple.factC, newD,
outputStoreSize);
}
@Override
protected D getEffectiveFactIn(QuadTuple<A, B, C, D> tuple) {
return tuple.factD;
}
@Override
protected NewD getEffectiveFactOut(QuadTuple<A, B, C, NewD> outTuple) {
return outTuple.factD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group0Mapping1CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class Group0Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, ResultContainer_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, UniTuple<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 UniTuple<A> createOutTuple(Void groupKey) {
return new UniTuple<>(null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTuple<A> outTuple, A a) {
outTuple.factA = a;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group0Mapping2CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group0Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<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::new);
}
@Override
protected BiTuple<A, B> createOutTuple(Void groupKey) {
return new BiTuple<>(null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, Pair<A, B> result) {
outTuple.factA = result.key();
outTuple.factB = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group0Mapping3CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group0Mapping3CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<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::new);
}
@Override
protected TriTuple<A, B, C> createOutTuple(Void groupKey) {
return new TriTuple<>(null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Triple<A, B, C> result) {
outTuple.factA = result.a();
outTuple.factB = result.b();
outTuple.factC = result.c();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group0Mapping4CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Quadruple;
public 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>, 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::new);
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Void groupKey) {
return new QuadTuple<>(null, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Quadruple<A, B, C, D> result) {
outTuple.factA = result.a();
outTuple.factB = result.b();
outTuple.factC = result.c();
outTuple.factD = result.d();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group1Mapping0CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class Group1Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, UniTuple<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.factA, tuple.factB, tuple.factC, tuple.factD);
}
@Override
protected UniTuple<A> createOutTuple(A a) {
return new UniTuple<>(a, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTuple<A> aUniTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group1Mapping1CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class Group1Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, ResultContainer_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<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 -> Group1Mapping0CollectorQuadNode.createGroupKey(groupKeyMapping, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected BiTuple<A, B> createOutTuple(A a) {
return new BiTuple<>(a, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, B b) {
outTuple.factB = b;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group1Mapping2CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group1Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<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 -> Group1Mapping0CollectorQuadNode.createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorQuadNode.mergeCollectors(collectorB, collectorC), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(A a) {
return new TriTuple<>(a, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Pair<B, C> result) {
outTuple.factB = result.key();
outTuple.factC = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group1Mapping3CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public 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>, 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 -> Group1Mapping0CollectorQuadNode.createGroupKey(groupKeyMapping, tuple),
Group0Mapping3CollectorQuadNode.mergeCollectors(collectorB, collectorC, collectorD), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(A a) {
return new QuadTuple<>(a, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Triple<B, C, D> result) {
outTuple.factB = result.a();
outTuple.factC = result.b();
outTuple.factD = result.c();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group2Mapping0CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<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.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
OldD oldD = tuple.factD;
A a = groupKeyMappingA.apply(oldA, oldB, oldC, oldD);
B b = groupKeyMappingB.apply(oldA, oldB, oldC, oldD);
return new Pair<>(a, b);
}
@Override
protected BiTuple<A, B> createOutTuple(Pair<A, B> groupKey) {
return new BiTuple<>(groupKey.key(), groupKey.value(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group2Mapping1CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, ResultContainer_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<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 -> Group2Mapping0CollectorQuadNode.createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(Pair<A, B> groupKey) {
return new TriTuple<>(groupKey.key(), groupKey.value(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, C c) {
outTuple.factC = c;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group2Mapping2CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<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 -> Group2Mapping0CollectorQuadNode.createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple),
Group0Mapping2CollectorQuadNode.mergeCollectors(collectorC, collectorD), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Pair<A, B> groupKey) {
return new QuadTuple<>(groupKey.key(), groupKey.value(), null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Pair<C, D> result) {
outTuple.factC = result.key();
outTuple.factD = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group3Mapping0CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group3Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<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.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
OldD oldD = tuple.factD;
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 new Triple<>(a, b, c);
}
@Override
protected TriTuple<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group3Mapping1CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group3Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainer_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<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 -> Group3Mapping0CollectorQuadNode.createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC,
tuple),
collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Triple<A, B, C> groupKey) {
return new QuadTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, D d) {
outTuple.factD = d;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/Group4Mapping0CollectorQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Quadruple;
public final class Group4Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<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.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
OldD oldD = tuple.factD;
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 new Quadruple<>(a, b, c, d);
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), groupKey.d(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/IndexedIfExistsQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractIndexedIfExistsNode;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class IndexedIfExistsQuadNode<A, B, C, D, E> extends AbstractIndexedIfExistsNode<QuadTuple<A, B, C, D>, E> {
private final PentaPredicate<A, B, C, D, E> filtering;
public IndexedIfExistsQuadNode(boolean shouldExist, IndexerFactory<E> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle) {
this(shouldExist, indexerFactory,
inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, -1,
inputStoreIndexRightKeys, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public IndexedIfExistsQuadNode(boolean shouldExist, IndexerFactory<E> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, PentaPredicate<A, B, C, D, E> filtering) {
super(shouldExist, indexerFactory.buildQuadLeftKeysExtractor(), indexerFactory,
inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightKeys, 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.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD,
rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/IndexedJoinQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractIndexedJoinNode;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class IndexedJoinQuadNode<A, B, C, D>
extends AbstractIndexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>> {
private final QuadPredicate<A, B, C, D> filtering;
private final int outputStoreSize;
public IndexedJoinQuadNode(IndexerFactory<D> indexerFactory,
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) {
super(indexerFactory.buildTriLeftKeysExtractor(), indexerFactory,
inputStoreIndexABC, inputStoreIndexEntryABC, inputStoreIndexOutTupleListABC,
inputStoreIndexD, inputStoreIndexEntryD, inputStoreIndexOutTupleListD,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexOutEntryABC, outputStoreIndexOutEntryD);
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, rightTuple.factA,
outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(QuadTuple<A, B, C, D> outTuple, TriTuple<A, B, C> leftTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void setOutTupleRightFact(QuadTuple<A, B, C, D> outTuple, UniTuple<D> rightTuple) {
outTuple.factD = rightTuple.factA;
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, leftTuple.factC, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/MapQuadToBiNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class MapQuadToBiNode<A, B, C, D, NewA, NewB> extends AbstractMapNode<QuadTuple<A, B, C, D>, BiTuple<NewA, NewB>> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
public MapQuadToBiNode(int mapStoreIndex, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB, TupleLifecycle<BiTuple<NewA, NewB>> nextNodesTupleLifecycle,
int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
}
@Override
protected BiTuple<NewA, NewB> map(QuadTuple<A, B, C, D> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
D factD = tuple.factD;
return new BiTuple<>(
mappingFunctionA.apply(factA, factB, factC, factD),
mappingFunctionB.apply(factA, factB, factC, factD),
outputStoreSize);
}
@Override
protected void remap(QuadTuple<A, B, C, D> inTuple, BiTuple<NewA, NewB> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
D factD = inTuple.factD;
NewA newA = mappingFunctionA.apply(factA, factB, factC, factD);
NewB newB = mappingFunctionB.apply(factA, factB, factC, factD);
outTuple.factA = newA;
outTuple.factB = newB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/MapQuadToQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class MapQuadToQuadNode<A, B, C, D, NewA, NewB, NewC, NewD>
extends AbstractMapNode<QuadTuple<A, B, C, D>, QuadTuple<NewA, NewB, NewC, NewD>> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private final QuadFunction<A, B, C, D, NewC> mappingFunctionC;
private final QuadFunction<A, B, C, D, NewD> mappingFunctionD;
public MapQuadToQuadNode(int mapStoreIndex, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB, QuadFunction<A, B, C, D, NewC> mappingFunctionC,
QuadFunction<A, B, C, D, NewD> mappingFunctionD,
TupleLifecycle<QuadTuple<NewA, NewB, NewC, NewD>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
this.mappingFunctionC = Objects.requireNonNull(mappingFunctionC);
this.mappingFunctionD = Objects.requireNonNull(mappingFunctionD);
}
@Override
protected QuadTuple<NewA, NewB, NewC, NewD> map(QuadTuple<A, B, C, D> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
D factD = tuple.factD;
return new QuadTuple<>(
mappingFunctionA.apply(factA, factB, factC, factD),
mappingFunctionB.apply(factA, factB, factC, factD),
mappingFunctionC.apply(factA, factB, factC, factD),
mappingFunctionD.apply(factA, factB, factC, factD),
outputStoreSize);
}
@Override
protected void remap(QuadTuple<A, B, C, D> inTuple, QuadTuple<NewA, NewB, NewC, NewD> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
D factD = inTuple.factD;
NewA newA = mappingFunctionA.apply(factA, factB, factC, factD);
NewB newB = mappingFunctionB.apply(factA, factB, factC, factD);
NewC newC = mappingFunctionC.apply(factA, factB, factC, factD);
NewD newD = mappingFunctionD.apply(factA, factB, factC, factD);
outTuple.factA = newA;
outTuple.factB = newB;
outTuple.factC = newC;
outTuple.factD = newD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/MapQuadToTriNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class MapQuadToTriNode<A, B, C, D, NewA, NewB, NewC>
extends AbstractMapNode<QuadTuple<A, B, C, D>, TriTuple<NewA, NewB, NewC>> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private final QuadFunction<A, B, C, D, NewC> mappingFunctionC;
public MapQuadToTriNode(int mapStoreIndex, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB, QuadFunction<A, B, C, D, NewC> mappingFunctionC,
TupleLifecycle<TriTuple<NewA, NewB, NewC>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
this.mappingFunctionC = Objects.requireNonNull(mappingFunctionC);
}
@Override
protected TriTuple<NewA, NewB, NewC> map(QuadTuple<A, B, C, D> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
D factD = tuple.factD;
return new TriTuple<>(
mappingFunctionA.apply(factA, factB, factC, factD),
mappingFunctionB.apply(factA, factB, factC, factD),
mappingFunctionC.apply(factA, factB, factC, factD),
outputStoreSize);
}
@Override
protected void remap(QuadTuple<A, B, C, D> inTuple, TriTuple<NewA, NewB, NewC> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
D factD = inTuple.factD;
NewA newA = mappingFunctionA.apply(factA, factB, factC, factD);
NewB newB = mappingFunctionB.apply(factA, factB, factC, factD);
NewC newC = mappingFunctionC.apply(factA, factB, factC, factD);
outTuple.factA = newA;
outTuple.factB = newB;
outTuple.factC = newC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/MapQuadToUniNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class MapQuadToUniNode<A, B, C, D, NewA> extends AbstractMapNode<QuadTuple<A, B, C, D>, UniTuple<NewA>> {
private final QuadFunction<A, B, C, D, NewA> mappingFunction;
public MapQuadToUniNode(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 UniTuple<NewA> map(QuadTuple<A, B, C, D> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
D factD = tuple.factD;
return new UniTuple<>(
mappingFunction.apply(factA, factB, factC, factD),
outputStoreSize);
}
@Override
protected void remap(QuadTuple<A, B, C, D> inTuple, UniTuple<NewA> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
D factD = inTuple.factD;
NewA newA = mappingFunction.apply(factA, factB, factC, factD);
outTuple.factA = newA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/UnindexedIfExistsQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractUnindexedIfExistsNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public 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.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD,
rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/UnindexedJoinQuadNode.java | package ai.timefold.solver.core.impl.bavet.quad;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractUnindexedJoinNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class UnindexedJoinQuadNode<A, B, C, D>
extends AbstractUnindexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<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 QuadTuple<A, B, C, D> createOutTuple(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, rightTuple.factA,
outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(QuadTuple<A, B, C, D> outTuple, TriTuple<A, B, C> leftTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void setOutTupleRightFact(QuadTuple<A, B, C, D> outTuple, UniTuple<D> rightTuple) {
outTuple.factD = rightTuple.factA;
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, leftTuple.factC, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/joiner/DefaultQuadJoiner.java | package ai.timefold.solver.core.impl.bavet.quad.joiner;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.AbstractJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.JoinerType;
import org.jspecify.annotations.NonNull;
public final class DefaultQuadJoiner<A, B, C, D> extends AbstractJoiner<D> implements QuadJoiner<A, B, C, D> {
private static final DefaultQuadJoiner NONE =
new DefaultQuadJoiner(new TriFunction[0], new JoinerType[0], new Function[0]);
private final TriFunction<A, B, C, ?>[] leftMappings;
public <Property_> DefaultQuadJoiner(TriFunction<A, B, C, Property_> leftMapping, JoinerType joinerType,
Function<D, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new TriFunction[] { leftMapping };
}
private <Property_> DefaultQuadJoiner(TriFunction<A, B, C, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<D, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C, D> DefaultQuadJoiner<A, B, C, D> merge(List<DefaultQuadJoiner<A, B, C, D>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultQuadJoiner::and);
}
@Override
public @NonNull DefaultQuadJoiner<A, B, C, D> and(@NonNull QuadJoiner<A, B, C, D> otherJoiner) {
DefaultQuadJoiner<A, B, C, D> castJoiner = (DefaultQuadJoiner<A, B, C, D>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
TriFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoiner.getJoinerCount(); i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultQuadJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public TriFunction<A, B, C, Object> getLeftMapping(int index) {
return (TriFunction<A, B, C, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c, D d) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b, c);
Object rightMapping = getRightMapping(i).apply(d);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (o instanceof DefaultQuadJoiner<?, ?, ?, ?> other) {
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/joiner/FilteringQuadJoiner.java | package ai.timefold.solver.core.impl.bavet.quad.joiner;
import java.util.Objects;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import org.jspecify.annotations.NonNull;
public final class FilteringQuadJoiner<A, B, C, D> implements QuadJoiner<A, B, C, D> {
private final QuadPredicate<A, B, C, D> filter;
public FilteringQuadJoiner(QuadPredicate<A, B, C, D> filter) {
this.filter = filter;
}
@Override
public @NonNull FilteringQuadJoiner<A, B, C, D> and(@NonNull QuadJoiner<A, B, C, D> otherJoiner) {
FilteringQuadJoiner<A, B, C, D> castJoiner = (FilteringQuadJoiner<A, B, C, D>) otherJoiner;
return new FilteringQuadJoiner<>(filter.and(castJoiner.getFilter()));
}
public QuadPredicate<A, B, C, D> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof FilteringQuadJoiner)) {
return false;
}
FilteringQuadJoiner<?, ?, ?, ?> other = (FilteringQuadJoiner<?, ?, ?, ?>) o;
return Objects.equals(filter, other.filter);
}
@Override
public int hashCode() {
return Objects.hash(getFilter());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/quad/joiner/QuadJoinerComber.java | package ai.timefold.solver.core.impl.bavet.quad.joiner;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
/**
* Combs an array of {@link QuadJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
* @param <C>
* @param <D>
*/
public final class QuadJoinerComber<A, B, C, D> {
public static <A, B, C, D> QuadJoinerComber<A, B, C, D> comb(QuadJoiner<A, B, C, D>[] joiners) {
List<DefaultQuadJoiner<A, B, C, D>> defaultJoinerList = new ArrayList<>(joiners.length);
List<QuadPredicate<A, B, C, D>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
QuadJoiner<A, B, C, D> joiner = joiners[i];
if (joiner instanceof FilteringQuadJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringQuadJoiner<A, B, C, D>) joiner).getFilter());
} else if (joiner instanceof DefaultQuadJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultQuadJoiner<A, B, C, D>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultQuadJoiner<A, B, C, D> mergedJoiner = DefaultQuadJoiner.merge(defaultJoinerList);
QuadPredicate<A, B, C, D> mergedFiltering = mergeFiltering(filteringList);
return new QuadJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <A, B, C, D> QuadPredicate<A, B, C, D> mergeFiltering(List<QuadPredicate<A, B, C, D>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c, D d) -> {
for (QuadPredicate<A, B, C, D> predicate : filteringList) {
if (!predicate.test(a, b, c, d)) {
return false;
}
}
return true;
};
}
}
private final DefaultQuadJoiner<A, B, C, D> mergedJoiner;
private final QuadPredicate<A, B, C, D> mergedFiltering;
public QuadJoinerComber(DefaultQuadJoiner<A, B, C, D> mergedJoiner, QuadPredicate<A, B, C, D> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultQuadJoiner<A, B, C, D> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public QuadPredicate<A, B, C, D> getMergedFiltering() {
return mergedFiltering;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/AbstractGroupTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.function.Function;
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;
import ai.timefold.solver.core.impl.bavet.common.AbstractGroupNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
abstract class AbstractGroupTriNode<OldA, OldB, OldC, OutTuple_ extends AbstractTuple, GroupKey_, ResultContainer_, Result_>
extends AbstractGroupNode<TriTuple<OldA, OldB, OldC>, OutTuple_, 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.factA, tuple.factB, tuple.factC);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/ConcatBiTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.function.BiFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatBiTriNode<A, B, C>
extends AbstractConcatNode<BiTuple<A, B>, TriTuple<A, B, C>, TriTuple<A, B, C>> {
private final BiFunction<A, B, C> paddingFunction;
public ConcatBiTriNode(BiFunction<A, B, C> paddingFunction,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunction = paddingFunction;
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(BiTuple<A, B> leftTuple) {
var factA = leftTuple.factA;
var factB = leftTuple.factB;
return new TriTuple<>(factA, factB, paddingFunction.apply(factA, factB), outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(TriTuple<A, B, C> rightTuple) {
return new TriTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(BiTuple<A, B> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
}
@Override
protected void updateOutTupleFromRight(TriTuple<A, B, C> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/ConcatTriBiNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.function.BiFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatTriBiNode<A, B, C>
extends AbstractConcatNode<TriTuple<A, B, C>, BiTuple<A, B>, TriTuple<A, B, C>> {
private final BiFunction<A, B, C> paddingFunction;
public ConcatTriBiNode(BiFunction<A, B, C> paddingFunction,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunction = paddingFunction;
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(TriTuple<A, B, C> leftTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(BiTuple<A, B> rightTuple) {
var factA = rightTuple.factA;
var factB = rightTuple.factB;
return new TriTuple<>(factA, factB, paddingFunction.apply(factA, factB), outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(TriTuple<A, B, C> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void updateOutTupleFromRight(BiTuple<A, B> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/ConcatTriTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class ConcatTriTriNode<A, B, C>
extends AbstractConcatNode<TriTuple<A, B, C>, TriTuple<A, B, C>, TriTuple<A, B, C>> {
public ConcatTriTriNode(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(TriTuple<A, B, C> leftTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(TriTuple<A, B, C> rightTuple) {
return new TriTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(TriTuple<A, B, C> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void updateOutTupleFromRight(TriTuple<A, B, C> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/ConcatTriUniNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class ConcatTriUniNode<A, B, C>
extends AbstractConcatNode<TriTuple<A, B, C>, UniTuple<A>, TriTuple<A, B, C>> {
private final Function<A, B> paddingFunctionB;
private final Function<A, C> paddingFunctionC;
public ConcatTriUniNode(Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(TriTuple<A, B, C> leftTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(UniTuple<A> rightTuple) {
var factA = rightTuple.factA;
return new TriTuple<>(factA,
paddingFunctionB.apply(factA), paddingFunctionC.apply(factA),
outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(TriTuple<A, B, C> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void updateOutTupleFromRight(UniTuple<A> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/ConcatUniTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class ConcatUniTriNode<A, B, C>
extends AbstractConcatNode<UniTuple<A>, TriTuple<A, B, C>, TriTuple<A, B, C>> {
private final Function<A, B> paddingFunctionB;
private final Function<A, C> paddingFunctionC;
public ConcatUniTriNode(Function<A, B> paddingFunctionB, Function<A, C> paddingFunctionC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList,
outputStoreSize);
this.paddingFunctionB = paddingFunctionB;
this.paddingFunctionC = paddingFunctionC;
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(UniTuple<A> leftTuple) {
var factA = leftTuple.factA;
return new TriTuple<>(factA,
paddingFunctionB.apply(factA), paddingFunctionC.apply(factA),
outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(TriTuple<A, B, C> rightTuple) {
return new TriTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(UniTuple<A> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
}
@Override
protected void updateOutTupleFromRight(TriTuple<A, B, C> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.