index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/StaticPropagationQueue.java | package ai.timefold.solver.constraint.streams.bavet.common;
import java.util.ArrayDeque;
import java.util.Deque;
import java.util.function.Consumer;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.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 Consumer<Tuple_> retractPropagator;
private final Consumer<Tuple_> updatePropagator;
private final Consumer<Tuple_> insertPropagator;
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);
// Don't create these lambdas over and over again.
this.retractPropagator = nextNodesTupleLifecycle::retract;
this.updatePropagator = nextNodesTupleLifecycle::update;
this.insertPropagator = nextNodesTupleLifecycle::insert;
}
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 (" + carrier + ") is already in the insert queue.");
}
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) {
if (carrier.state == state) { // Skip double retracts.
return;
}
if (state.isActive() || state == TupleState.DEAD) {
throw new IllegalArgumentException("Impossible state: The state (" + state + ") is not a valid retract state.");
} else if (carrier.state == TupleState.ABORTING || carrier.state == TupleState.DYING) {
throw new IllegalStateException("Impossible state: The tuple (" + carrier + ") is already in the retract queue.");
}
carrier.state = state;
retractQueue.add(carrier);
}
@Override
public void propagateRetracts() {
if (retractQueue.isEmpty()) {
return;
}
for (Tuple_ tuple : retractQueue) {
switch (tuple.state) {
case DYING -> propagate(tuple, retractPropagator, TupleState.DEAD);
case ABORTING -> tuple.state = TupleState.DEAD;
}
}
retractQueue.clear();
}
private void propagate(Tuple_ tuple, Consumer<Tuple_> propagator, TupleState tupleState) {
// Change state before propagation, so that the next node can't make decisions on the original state.
tuple.state = tupleState;
propagator.accept(tuple);
}
@Override
public void propagateUpdates() {
processAndClear(updateQueue, updatePropagator);
}
private void processAndClear(Deque<Tuple_> dirtyQueue, Consumer<Tuple_> propagator) {
if (dirtyQueue.isEmpty()) {
return;
}
for (Tuple_ 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;
}
propagate(tuple, propagator, TupleState.OK);
}
dirtyQueue.clear();
}
@Override
public void propagateInserts() {
processAndClear(insertQueue, insertPropagator);
if (!retractQueue.isEmpty()) {
throw new IllegalStateException("Impossible state: The retract queue (" + retractQueue + ") is not empty.");
} else if (!updateQueue.isEmpty()) {
throw new IllegalStateException("Impossible state: The update queue (" + updateQueue + ") is not empty.");
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/TupleSource.java | package ai.timefold.solver.constraint.streams.bavet.common;
public interface TupleSource {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/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.constraint.streams.bavet.common; |
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetAftBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleSource;
import ai.timefold.solver.core.api.score.Score;
public final class BavetAftBridgeBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B>
implements TupleSource {
public BavetAftBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeBiConstraintStream<?, ?, ?> that = (BavetAftBridgeBiConstraintStream<?, ?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return parent.hashCode();
}
@Override
public String toString() {
return "Bridge from " + parent + " with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetAftBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleSource;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetAbstractQuadConstraintStream;
import ai.timefold.solver.core.api.score.Score;
public final class BavetAftBridgeQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements TupleSource {
public BavetAftBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeQuadConstraintStream<?, ?, ?, ?, ?> that = (BavetAftBridgeQuadConstraintStream<?, ?, ?, ?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return parent.hashCode();
}
@Override
public String toString() {
return "Bridge from " + parent + " with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetAftBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleSource;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetAbstractTriConstraintStream;
import ai.timefold.solver.core.api.score.Score;
public final class BavetAftBridgeTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements TupleSource {
public BavetAftBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeTriConstraintStream<?, ?, ?, ?> that = (BavetAftBridgeTriConstraintStream<?, ?, ?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return parent.hashCode();
}
@Override
public String toString() {
return "Bridge from " + parent + " with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetAftBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleSource;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.core.api.score.Score;
public final class BavetAftBridgeUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements TupleSource {
public BavetAftBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The parent stream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetAftBridgeUniConstraintStream<?, ?> that = (BavetAftBridgeUniConstraintStream<?, ?>) o;
return Objects.equals(parent, that.parent);
}
@Override
public int hashCode() {
return parent.hashCode();
}
@Override
public String toString() {
return "Bridge from " + parent + " with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetForeBridgeBiConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetForeBridgeBiConstraintStream<Solution_, A, B>
extends BavetAbstractBiConstraintStream<Solution_, A, B> {
public BavetForeBridgeBiConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractBiConstraintStream<Solution_, A, B> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetForeBridgeQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetAbstractQuadConstraintStream;
import ai.timefold.solver.core.api.score.Score;
public final class BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
public BavetForeBridgeQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetForeBridgeTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetAbstractTriConstraintStream;
import ai.timefold.solver.core.api.score.Score;
public final class BavetForeBridgeTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
public BavetForeBridgeTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/BavetForeBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.common.bridge;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.core.api.score.Score;
public final class BavetForeBridgeUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
public BavetForeBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent) {
super(constraintFactory, parent);
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. The child stream builds everything.
}
@Override
public String toString() {
return "Generic bridge";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/bridge/package-info.java | /**
* Contains streams that serve as bridges.
* Fore bridges go before the stream they bridge,
* while aft bridges go after.
* <p>
* Aft bridges are node-shared,
* therefore their {@link java.lang.Object#equals(java.lang.Object)} and {@link java.lang.Object#hashCode()} (java.lang.Object)}
* methods are overridden to reference the bridged stream,
* which carries all the equality data.
* <p>
* Fore bridges are node-shared through their child stream
* and therefore the equality logic can reside there entirely.
*/
package ai.timefold.solver.constraint.streams.bavet.common.bridge; |
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/ComparisonIndexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Comparator;
import java.util.Map;
import java.util.NavigableMap;
import java.util.Objects;
import java.util.TreeMap;
import java.util.function.Consumer;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
final class ComparisonIndexer<T, Key_ extends Comparable<Key_>> implements Indexer<T> {
private final int propertyIndex;
private final Supplier<Indexer<T>> downstreamIndexerSupplier;
private final Comparator<Key_> keyComparator;
private final boolean hasOrEquals;
private final NavigableMap<Key_, Indexer<T>> comparisonMap;
public ComparisonIndexer(JoinerType comparisonJoinerType, Supplier<Indexer<T>> downstreamIndexerSupplier) {
this(comparisonJoinerType, 0, downstreamIndexerSupplier);
}
public ComparisonIndexer(JoinerType comparisonJoinerType, int propertyIndex,
Supplier<Indexer<T>> downstreamIndexerSupplier) {
this.propertyIndex = propertyIndex;
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(IndexProperties indexProperties, T tuple) {
Key_ indexKey = indexProperties.toKey(propertyIndex);
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
Indexer<T> downstreamIndexer = comparisonMap.get(indexKey);
if (downstreamIndexer == null) {
downstreamIndexer = downstreamIndexerSupplier.get();
comparisonMap.put(indexKey, downstreamIndexer);
}
return downstreamIndexer.put(indexProperties, tuple);
}
@Override
public void remove(IndexProperties indexProperties, ElementAwareListEntry<T> entry) {
Key_ indexKey = indexProperties.toKey(propertyIndex);
Indexer<T> downstreamIndexer = getDownstreamIndexer(indexProperties, indexKey, entry);
downstreamIndexer.remove(indexProperties, entry);
if (downstreamIndexer.isEmpty()) {
comparisonMap.remove(indexKey);
}
}
private Indexer<T> getDownstreamIndexer(IndexProperties indexProperties, Key_ indexerKey,
ElementAwareListEntry<T> entry) {
Indexer<T> downstreamIndexer = comparisonMap.get(indexerKey);
if (downstreamIndexer == null) {
throw new IllegalStateException("Impossible state: the tuple (" + entry.getElement()
+ ") with indexProperties (" + indexProperties
+ ") doesn't exist in the indexer " + this + ".");
}
return downstreamIndexer;
}
// TODO clean up DRY
@Override
public int size(IndexProperties indexProperties) {
int mapSize = comparisonMap.size();
if (mapSize == 0) {
return 0;
}
Key_ indexKey = indexProperties.toKey(propertyIndex);
if (mapSize == 1) { // Avoid creation of the entry set and iterator.
Map.Entry<Key_, Indexer<T>> entry = comparisonMap.firstEntry();
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
return 0;
}
}
return entry.getValue().size(indexProperties);
} else {
int size = 0;
for (Map.Entry<Key_, Indexer<T>> entry : comparisonMap.entrySet()) {
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
break;
}
}
// Boundary condition not yet reached; include the indexer in the range.
size += entry.getValue().size(indexProperties);
}
return size;
}
}
@Override
public void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer) {
int size = comparisonMap.size();
if (size == 0) {
return;
}
Key_ indexKey = indexProperties.toKey(propertyIndex);
if (size == 1) { // Avoid creation of the entry set and iterator.
Map.Entry<Key_, Indexer<T>> entry = comparisonMap.firstEntry();
visitEntry(indexProperties, tupleConsumer, indexKey, entry);
} else {
for (Map.Entry<Key_, Indexer<T>> entry : comparisonMap.entrySet()) {
boolean boundaryReached = visitEntry(indexProperties, tupleConsumer, indexKey, entry);
if (boundaryReached) {
return;
}
}
}
}
private boolean visitEntry(IndexProperties indexProperties, Consumer<T> tupleConsumer,
Key_ indexKey, Map.Entry<Key_, Indexer<T>> entry) {
// Comparator matches the order of iteration of the map, so the boundary is always found from the bottom up.
int comparison = keyComparator.compare(entry.getKey(), indexKey);
if (comparison >= 0) { // Possibility of reaching the boundary condition.
if (comparison > 0 || !hasOrEquals) {
// Boundary condition reached when we're out of bounds entirely, or when GTE/LTE is not allowed.
return true;
}
}
// Boundary condition not yet reached; include the indexer in the range.
entry.getValue().forEach(indexProperties, tupleConsumer);
return false;
}
@Override
public boolean isEmpty() {
return comparisonMap.isEmpty();
}
@Override
public String toString() {
return "size = " + comparisonMap.size();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/EqualsIndexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.HashMap;
import java.util.Map;
import java.util.Objects;
import java.util.function.Consumer;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
final class EqualsIndexer<T, Key_> implements Indexer<T> {
private final int propertyIndex;
private final Supplier<Indexer<T>> downstreamIndexerSupplier;
private final Map<Key_, Indexer<T>> downstreamIndexerMap = new HashMap<>();
public EqualsIndexer(Supplier<Indexer<T>> downstreamIndexerSupplier) {
this(0, downstreamIndexerSupplier);
}
public EqualsIndexer(int propertyIndex, Supplier<Indexer<T>> downstreamIndexerSupplier) {
this.propertyIndex = propertyIndex;
this.downstreamIndexerSupplier = Objects.requireNonNull(downstreamIndexerSupplier);
}
@Override
public ElementAwareListEntry<T> put(IndexProperties indexProperties, T tuple) {
Key_ indexKey = indexProperties.toKey(propertyIndex);
// Avoids computeIfAbsent in order to not create lambdas on the hot path.
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null) {
downstreamIndexer = downstreamIndexerSupplier.get();
downstreamIndexerMap.put(indexKey, downstreamIndexer);
}
return downstreamIndexer.put(indexProperties, tuple);
}
@Override
public void remove(IndexProperties indexProperties, ElementAwareListEntry<T> entry) {
Key_ indexKey = indexProperties.toKey(propertyIndex);
Indexer<T> downstreamIndexer = getDownstreamIndexer(indexProperties, indexKey, entry);
downstreamIndexer.remove(indexProperties, entry);
if (downstreamIndexer.isEmpty()) {
downstreamIndexerMap.remove(indexKey);
}
}
private Indexer<T> getDownstreamIndexer(IndexProperties indexProperties, Key_ indexerKey,
ElementAwareListEntry<T> entry) {
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexerKey);
if (downstreamIndexer == null) {
throw new IllegalStateException("Impossible state: the tuple (" + entry.getElement()
+ ") with indexProperties (" + indexProperties
+ ") doesn't exist in the indexer " + this + ".");
}
return downstreamIndexer;
}
@Override
public int size(IndexProperties indexProperties) {
Key_ indexKey = indexProperties.toKey(propertyIndex);
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null) {
return 0;
}
return downstreamIndexer.size(indexProperties);
}
@Override
public void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer) {
Key_ indexKey = indexProperties.toKey(propertyIndex);
Indexer<T> downstreamIndexer = downstreamIndexerMap.get(indexKey);
if (downstreamIndexer == null) {
return;
}
downstreamIndexer.forEach(indexProperties, tupleConsumer);
}
@Override
public boolean isEmpty() {
return downstreamIndexerMap.isEmpty();
}
@Override
public String toString() {
return "size = " + downstreamIndexerMap.size();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/IndexProperties.java | package ai.timefold.solver.constraint.streams.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.
*/
public sealed interface IndexProperties
permits ManyIndexProperties, NoneIndexProperties, SingleIndexProperties, ThreeIndexProperties, TwoIndexProperties {
/**
* Retrieves index property at a given position.
*
* @param id Maps to a single {@link Indexer} instance in the indexer chain.
* @return never null
* @param <Type_> {@link ComparisonIndexer} will expect this to implement {@link Comparable}.
* {@link EqualsIndexer} will treat items as the same if they are equal.
*/
<Type_> Type_ toKey(int id);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/Indexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.function.Consumer;
import ai.timefold.solver.constraint.streams.bavet.common.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 indexProperties},
* to all instances of {@code X} that match those properties,
* depending on the the indexer type (equal, lower than, ...).
* For example for {@code {Lesson(id=1, room=A), Lesson(id=2, room=B), Lesson(id=3, room=A)}},
* calling {@code visit(room=A)} would visit lesson 1 and 3.
* <p>
* The fact X is wrapped in a Tuple, because the {@link TupleState} is needed by clients of
* {@link #forEach(IndexProperties, Consumer)}.
*
* @param <T> The element type. Often a tuple.
* For example for {@code from(A).join(B)}, the tuple is {@code UniTuple<A>} xor {@code UniTuple<B>}.
* For example for {@code Bi<A, B>.join(C)}, the tuple is {@code BiTuple<A, B>} xor {@code UniTuple<C>}.
*/
public sealed interface Indexer<T> permits ComparisonIndexer, EqualsIndexer, NoneIndexer {
ElementAwareListEntry<T> put(IndexProperties indexProperties, T tuple);
void remove(IndexProperties indexProperties, ElementAwareListEntry<T> entry);
int size(IndexProperties indexProperties);
void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer);
boolean isEmpty();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/IndexerFactory.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.ArrayList;
import java.util.NavigableMap;
import java.util.TreeMap;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.constraint.streams.common.bi.DefaultBiJoiner;
import ai.timefold.solver.constraint.streams.common.penta.DefaultPentaJoiner;
import ai.timefold.solver.constraint.streams.common.quad.DefaultQuadJoiner;
import ai.timefold.solver.constraint.streams.common.tri.DefaultTriJoiner;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
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 IndexProperties} instance,
* which determines its location in the index.
* {@link IndexProperties} instances are built from {@link AbstractJoiner joiners}
* using methods such as {@link #buildUniLeftMapping()} and {@link #buildRightMapping()}.
* Each {@link IndexProperties#toKey(int) index keyFunction} has an id,
* and this id matches the id of the indexer;
* each keyFunction in {@link IndexProperties} 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 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> Function<A, IndexProperties> buildUniLeftMapping() {
var joinerCount = joiner.getJoinerCount();
var castJoiner = (DefaultBiJoiner<A, Right_>) joiner;
return switch (joinerCount) {
case 0 -> a -> NoneIndexProperties.INSTANCE;
case 1 -> {
var mapping = castJoiner.getLeftMapping(0);
yield a -> new SingleIndexProperties<>(mapping.apply(a));
}
default -> {
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 -> castJoiner.getLeftMapping(startIndexInclusive);
case 2 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
yield a -> new Pair<>(mapping1.apply(a), mapping2.apply(a));
}
case 3 -> {
var mapping1 = castJoiner.getLeftMapping(startIndexInclusive);
var mapping2 = castJoiner.getLeftMapping(startIndexInclusive + 1);
var mapping3 = castJoiner.getLeftMapping(startIndexInclusive + 2);
yield a -> new Triple<>(mapping1.apply(a), mapping2.apply(a), mapping3.apply(a));
}
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 -> 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 = castJoiner.getLeftMapping(i);
mappings[i] = mapping;
}
yield a -> {
int mappingCount = mappings.length;
var result = new Object[mappingCount];
for (int i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
int keyFunctionCount = keyFunctionList.size();
switch (keyFunctionCount) {
case 1 -> {
var keyFunction = keyFunctionList.get(0);
yield a -> new SingleIndexProperties<>(keyFunction.apply(a));
}
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield a -> new TwoIndexProperties<>(keyFunction1.apply(a), keyFunction2.apply(a));
}
case 3 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
var keyFunction3 = keyFunctionList.get(2);
yield a -> new ThreeIndexProperties<>(keyFunction1.apply(a), keyFunction2.apply(a),
keyFunction3.apply(a));
}
default -> {
yield a -> {
Object[] arr = new Object[keyFunctionCount];
for (int i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a);
}
return new ManyIndexProperties(arr);
};
}
}
}
};
}
public <A, B> BiFunction<A, B, IndexProperties> buildBiLeftMapping() {
var joinerCount = joiner.getJoinerCount();
var castJoiner = (DefaultTriJoiner<A, B, Right_>) joiner;
return switch (joinerCount) {
case 0 -> (a, b) -> NoneIndexProperties.INSTANCE;
case 1 -> {
var mapping = castJoiner.getLeftMapping(0);
yield (a, b) -> new SingleIndexProperties<>(mapping.apply(a, b));
}
default -> {
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) -> {
int mappingCount = mappings.length;
var result = new Object[mappingCount];
for (int i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a, b);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
int keyFunctionCount = keyFunctionList.size();
switch (keyFunctionCount) {
case 1 -> {
var keyFunction = keyFunctionList.get(0);
yield (a, b) -> new SingleIndexProperties<>(keyFunction.apply(a, b));
}
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield (a, b) -> new TwoIndexProperties<>(keyFunction1.apply(a, b), keyFunction2.apply(a, b));
}
case 3 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
var keyFunction3 = keyFunctionList.get(2);
yield (a, b) -> new ThreeIndexProperties<>(keyFunction1.apply(a, b), keyFunction2.apply(a, b),
keyFunction3.apply(a, b));
}
default -> {
yield (a, b) -> {
Object[] arr = new Object[keyFunctionCount];
for (int i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a, b);
}
return new ManyIndexProperties(arr);
};
}
}
}
};
}
public <A, B, C> TriFunction<A, B, C, IndexProperties> buildTriLeftMapping() {
var joinerCount = joiner.getJoinerCount();
var castJoiner = (DefaultQuadJoiner<A, B, C, Right_>) joiner;
return switch (joinerCount) {
case 0 -> (a, b, c) -> NoneIndexProperties.INSTANCE;
case 1 -> {
var mapping = castJoiner.getLeftMapping(0);
yield (a, b, c) -> new SingleIndexProperties<>(mapping.apply(a, b, c));
}
default -> {
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) -> {
int mappingCount = mappings.length;
var result = new Object[mappingCount];
for (int i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a, b, c);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
int keyFunctionCount = keyFunctionList.size();
switch (keyFunctionCount) {
case 1 -> {
var keyFunction = keyFunctionList.get(0);
yield (a, b, c) -> new SingleIndexProperties<>(keyFunction.apply(a, b, c));
}
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield (a, b, c) -> new TwoIndexProperties<>(keyFunction1.apply(a, b, c), keyFunction2.apply(a, b, c));
}
case 3 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
var keyFunction3 = keyFunctionList.get(2);
yield (a, b, c) -> new ThreeIndexProperties<>(keyFunction1.apply(a, b, c), keyFunction2.apply(a, b, c),
keyFunction3.apply(a, b, c));
}
default -> {
yield (a, b, c) -> {
Object[] arr = new Object[keyFunctionCount];
for (int i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a, b, c);
}
return new ManyIndexProperties(arr);
};
}
}
}
};
}
public <A, B, C, D> QuadFunction<A, B, C, D, IndexProperties> buildQuadLeftMapping() {
var joinerCount = joiner.getJoinerCount();
var castJoiner = (DefaultPentaJoiner<A, B, C, D, Right_>) joiner;
return switch (joinerCount) {
case 0 -> (a, b, c, d) -> NoneIndexProperties.INSTANCE;
case 1 -> {
var mapping = castJoiner.getLeftMapping(0);
yield (a, b, c, d) -> new SingleIndexProperties<>(mapping.apply(a, b, c, d));
}
default -> {
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) -> {
int mappingCount = mappings.length;
var result = new Object[mappingCount];
for (int i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a, b, c, d);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
int keyFunctionCount = keyFunctionList.size();
switch (keyFunctionList.size()) {
case 1 -> {
var keyFunction = keyFunctionList.get(0);
yield (a, b, c, d) -> new SingleIndexProperties<>(keyFunction.apply(a, b, c, d));
}
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield (a, b, c, d) -> new TwoIndexProperties<>(keyFunction1.apply(a, b, c, d),
keyFunction2.apply(a, b, c, d));
}
case 3 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
var keyFunction3 = keyFunctionList.get(2);
yield (a, b, c, d) -> new ThreeIndexProperties<>(keyFunction1.apply(a, b, c, d),
keyFunction2.apply(a, b, c, d),
keyFunction3.apply(a, b, c, d));
}
default -> {
yield (a, b, c, d) -> {
Object[] arr = new Object[keyFunctionCount];
for (int i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a, b, c, d);
}
return new ManyIndexProperties(arr);
};
}
}
}
};
}
public Function<Right_, IndexProperties> buildRightMapping() {
var joinerCount = joiner.getJoinerCount();
return switch (joinerCount) {
case 0 -> a -> NoneIndexProperties.INSTANCE;
case 1 -> {
var mapping = joiner.getRightMapping(0);
yield a -> new SingleIndexProperties<>(mapping.apply(a));
}
default -> {
var startIndexInclusive = 0;
var keyFunctionList = new ArrayList<Function<Right_, 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<Right_, Object> keyFunction = switch (keyFunctionLength) {
case 1 -> joiner.getRightMapping(startIndexInclusive);
case 2 -> {
var mapping1 = joiner.getRightMapping(startIndexInclusive);
var mapping2 = joiner.getRightMapping(startIndexInclusive + 1);
yield a -> new Pair<>(mapping1.apply(a), mapping2.apply(a));
}
case 3 -> {
var mapping1 = joiner.getRightMapping(startIndexInclusive);
var mapping2 = joiner.getRightMapping(startIndexInclusive + 1);
var mapping3 = joiner.getRightMapping(startIndexInclusive + 2);
yield a -> new Triple<>(mapping1.apply(a), mapping2.apply(a), mapping3.apply(a));
}
case 4 -> {
var mapping1 = joiner.getRightMapping(startIndexInclusive);
var mapping2 = joiner.getRightMapping(startIndexInclusive + 1);
var mapping3 = joiner.getRightMapping(startIndexInclusive + 2);
var mapping4 = joiner.getRightMapping(startIndexInclusive + 3);
yield a -> new Quadruple<>(mapping1.apply(a), mapping2.apply(a), mapping3.apply(a),
mapping4.apply(a));
}
default -> {
Function<Right_, Object>[] mappings = new Function[joinerCount];
for (var i = 0; i < joinerCount; i++) {
var mapping = joiner.getRightMapping(i);
mappings[i] = mapping;
}
yield a -> {
int mappingCount = mappings.length;
var result = new Object[mappingCount];
for (int i = 0; i < mappingCount; i++) {
result[i] = mappings[i].apply(a);
}
return new IndexerKey(result);
};
}
};
keyFunctionList.add(keyFunction);
startIndexInclusive = endIndexExclusive;
}
int keyFunctionCount = keyFunctionList.size();
switch (keyFunctionCount) {
case 1 -> {
var keyFunction = keyFunctionList.get(0);
yield a -> new SingleIndexProperties<>(keyFunction.apply(a));
}
case 2 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
yield a -> new TwoIndexProperties<>(keyFunction1.apply(a), keyFunction2.apply(a));
}
case 3 -> {
var keyFunction1 = keyFunctionList.get(0);
var keyFunction2 = keyFunctionList.get(1);
var keyFunction3 = keyFunctionList.get(2);
yield a -> new ThreeIndexProperties<>(keyFunction1.apply(a), keyFunction2.apply(a),
keyFunction3.apply(a));
}
default -> {
yield a -> {
Object[] arr = new Object[keyFunctionCount];
for (int i = 0; i < keyFunctionCount; i++) {
arr[i] = keyFunctionList.get(i).apply(a);
}
return new ManyIndexProperties(arr);
};
}
}
}
};
}
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<>(NoneIndexer::new);
} else {
return new ComparisonIndexer<>(isLeftBridge ? joinerType : joinerType.flip(), NoneIndexer::new);
}
}
// 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>> downstreamIndexerSupplier = NoneIndexer::new;
var indexPropertyId = descendingJoinerTypeMap.size() - 1;
for (var entry : descendingJoinerTypeMap.entrySet()) {
var joinerType = entry.getValue();
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();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/IndexerKey.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Arrays;
import ai.timefold.solver.core.impl.util.Pair;
import ai.timefold.solver.core.impl.util.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/ManyIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.Arrays;
record ManyIndexProperties(Object... properties) implements IndexProperties {
@Override
public <Type_> Type_ toKey(int id) {
return (Type_) properties[id];
}
@Override
public boolean equals(Object o) {
if (o instanceof ManyIndexProperties other) {
return Arrays.equals(properties, other.properties);
}
return false;
}
@Override
public int hashCode() {
return Arrays.hashCode(properties);
}
@Override
public String toString() {
return Arrays.toString(properties);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/NoneIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
final class NoneIndexProperties implements IndexProperties {
static final NoneIndexProperties INSTANCE = new NoneIndexProperties();
private NoneIndexProperties() {
}
@Override
public <Type_> Type_ toKey(int id) {
throw new IllegalArgumentException("Impossible state: none index property requested");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/NoneIndexer.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
import java.util.function.Consumer;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
final class NoneIndexer<T> implements Indexer<T> {
private final ElementAwareList<T> tupleList = new ElementAwareList<>();
@Override
public ElementAwareListEntry<T> put(IndexProperties indexProperties, T tuple) {
return tupleList.add(tuple);
}
@Override
public void remove(IndexProperties indexProperties, ElementAwareListEntry<T> entry) {
entry.remove();
}
@Override
public int size(IndexProperties indexProperties) {
return tupleList.size();
}
@Override
public void forEach(IndexProperties indexProperties, Consumer<T> tupleConsumer) {
tupleList.forEach(tupleConsumer);
}
@Override
public boolean isEmpty() {
return tupleList.size() == 0;
}
@Override
public String toString() {
return "size = " + tupleList.size();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/SingleIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
record SingleIndexProperties<A>(A property) implements IndexProperties {
@Override
public <Type_> Type_ toKey(int id) {
if (id != 0) {
throw new IllegalArgumentException("Impossible state: index (" + id + ") != 0");
}
return (Type_) property;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/ThreeIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
record ThreeIndexProperties<A, B, C>(A propertyA, B propertyB, C propertyC) implements IndexProperties {
@Override
public <Type_> Type_ toKey(int id) {
return (Type_) switch (id) {
case 0 -> propertyA;
case 1 -> propertyB;
case 2 -> propertyC;
default -> throw new IllegalArgumentException("Impossible state: index (" + id + ") != 0");
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/TwoIndexProperties.java | package ai.timefold.solver.constraint.streams.bavet.common.index;
record TwoIndexProperties<A, B>(A propertyA, B propertyB) implements IndexProperties {
@Override
public <Type_> Type_ toKey(int id) {
return (Type_) switch (id) {
case 0 -> propertyA;
case 1 -> propertyB;
default -> throw new IllegalArgumentException("Impossible state: index (" + id + ") != 0");
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/index/package-info.java | /**
* This package contains code that deals with indexing of tuples.
* The entry point is {@link ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory},
* which also contains a description of the entire mechanism.
*/
package ai.timefold.solver.constraint.streams.bavet.common.index; |
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/AbstractConditionalTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common.tuple;
import java.util.Objects;
public abstract class AbstractConditionalTupleLifecycle<Tuple_ extends AbstractTuple>
implements TupleLifecycle<Tuple_> {
private final TupleLifecycle<Tuple_> tupleLifecycle;
protected AbstractConditionalTupleLifecycle(TupleLifecycle<Tuple_> tupleLifecycle) {
this.tupleLifecycle = Objects.requireNonNull(tupleLifecycle);
}
@Override
public final void insert(Tuple_ tuple) {
if (test(tuple)) {
tupleLifecycle.insert(tuple);
}
}
@Override
public final void update(Tuple_ tuple) {
if (test(tuple)) {
tupleLifecycle.update(tuple);
} else {
tupleLifecycle.retract(tuple);
}
}
@Override
public final void retract(Tuple_ tuple) {
tupleLifecycle.retract(tuple);
}
abstract protected boolean test(Tuple_ tuple);
@Override
public String toString() {
return "Conditional " + tupleLifecycle;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/AbstractTuple.java | package ai.timefold.solver.constraint.streams.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 {
/*
* We create a lot of tuples, many of them having store size of 1.
* If an array of size 1 was created for each such tuple, memory would be wasted and indirection created.
* This trade-off of increased memory efficiency for marginally slower access time is proven beneficial.
*/
private final boolean storeIsArray;
private Object store;
public TupleState state = TupleState.DEAD; // It's the node's job to mark a new tuple as CREATING.
protected AbstractTuple(int storeSize) {
this.store = (storeSize < 2) ? null : new Object[storeSize];
this.storeIsArray = store != null;
}
public final <Value_> Value_ getStore(int index) {
return (Value_) (storeIsArray ? ((Object[]) store)[index] : store);
}
public final void setStore(int index, Object value) {
if (storeIsArray) {
((Object[]) store)[index] = value;
} else {
store = value;
}
}
public <Value_> Value_ removeStore(int index) {
Value_ value;
if (storeIsArray) {
Object[] array = (Object[]) store;
value = (Value_) array[index];
array[index] = null;
} else {
value = (Value_) store;
store = null;
}
return value;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/AggregatedTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common.tuple;
final class AggregatedTupleLifecycle<Tuple_ extends AbstractTuple> implements TupleLifecycle<Tuple_> {
private final TupleLifecycle<Tuple_>[] lifecycles;
public AggregatedTupleLifecycle(TupleLifecycle<Tuple_>[] lifecycles) {
this.lifecycles = lifecycles;
}
@Override
public void insert(Tuple_ tuple) {
for (TupleLifecycle<Tuple_> lifecycle : lifecycles) {
lifecycle.insert(tuple);
}
}
@Override
public void update(Tuple_ tuple) {
for (TupleLifecycle<Tuple_> lifecycle : lifecycles) {
lifecycle.update(tuple);
}
}
@Override
public void retract(Tuple_ tuple) {
for (TupleLifecycle<Tuple_> lifecycle : lifecycles) {
lifecycle.retract(tuple);
}
}
@Override
public String toString() {
return "size = " + lifecycles.length;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/BiTuple.java | package ai.timefold.solver.constraint.streams.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/LeftTupleLifecycle.java | package ai.timefold.solver.constraint.streams.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/LeftTupleLifecycleImpl.java | package ai.timefold.solver.constraint.streams.bavet.common.tuple;
import java.util.Objects;
final class LeftTupleLifecycleImpl<Tuple_ extends AbstractTuple>
implements TupleLifecycle<Tuple_> {
private final LeftTupleLifecycle<Tuple_> leftTupleLifecycle;
LeftTupleLifecycleImpl(LeftTupleLifecycle<Tuple_> leftTupleLifecycle) {
this.leftTupleLifecycle = Objects.requireNonNull(leftTupleLifecycle);
}
@Override
public void insert(Tuple_ tuple) {
leftTupleLifecycle.insertLeft(tuple);
}
@Override
public void update(Tuple_ tuple) {
leftTupleLifecycle.updateLeft(tuple);
}
@Override
public void retract(Tuple_ tuple) {
leftTupleLifecycle.retractLeft(tuple);
}
@Override
public String toString() {
return "left " + leftTupleLifecycle;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/QuadTuple.java | package ai.timefold.solver.constraint.streams.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/RightTupleLifecycle.java | package ai.timefold.solver.constraint.streams.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/RightTupleLifecycleImpl.java | package ai.timefold.solver.constraint.streams.bavet.common.tuple;
import java.util.Objects;
final class RightTupleLifecycleImpl<Tuple_ extends AbstractTuple>
implements TupleLifecycle<Tuple_> {
private final RightTupleLifecycle<Tuple_> rightTupleLifecycle;
RightTupleLifecycleImpl(RightTupleLifecycle<Tuple_> rightTupleLifecycle) {
this.rightTupleLifecycle = Objects.requireNonNull(rightTupleLifecycle);
}
@Override
public void insert(Tuple_ tuple) {
rightTupleLifecycle.insertRight(tuple);
}
@Override
public void update(Tuple_ tuple) {
rightTupleLifecycle.updateRight(tuple);
}
@Override
public void retract(Tuple_ tuple) {
rightTupleLifecycle.retractRight(tuple);
}
@Override
public String toString() {
return "right " + rightTupleLifecycle;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/TriTuple.java | package ai.timefold.solver.constraint.streams.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/TupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.common.tuple;
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);
}
static <Tuple_ extends AbstractTuple> TupleLifecycle<Tuple_> of(TupleLifecycle<Tuple_>... tupleLifecycles) {
return new AggregatedTupleLifecycle<>(tupleLifecycles);
}
void insert(Tuple_ tuple);
void update(Tuple_ tuple);
void retract(Tuple_ tuple);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/TupleState.java | package ai.timefold.solver.constraint.streams.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/common/tuple/UniTuple.java | package ai.timefold.solver.constraint.streams.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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/AbstractGroupQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractGroupNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
abstract class AbstractGroupQuadNode<OldA, OldB, OldC, OldD, OutTuple_ extends 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetAbstractQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.fourKeysGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.oneKeyGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.threeKeysGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.twoKeysGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.zeroKeysGroupBy;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetAbstractTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.constraint.streams.common.penta.PentaJoinerComber;
import ai.timefold.solver.constraint.streams.common.quad.InnerQuadConstraintStream;
import ai.timefold.solver.constraint.streams.common.quad.QuadConstraintBuilderImpl;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
public abstract class BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractConstraintStream<Solution_>
implements InnerQuadConstraintStream<A, B, C, D> {
protected BavetAbstractQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
protected BavetAbstractQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> filter(QuadPredicate<A, B, C, D> predicate) {
return shareAndAddChild(new BavetFilterQuadConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final <E> QuadConstraintStream<A, B, C, D> ifExists(Class<E> otherClass, PentaJoiner<A, B, C, D, E>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
@Override
public final <E> QuadConstraintStream<A, B, C, D> ifExistsIncludingUnassigned(Class<E> otherClass,
PentaJoiner<A, B, C, D, E>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <E> QuadConstraintStream<A, B, C, D> ifExists(UniConstraintStream<E> otherStream,
PentaJoiner<A, B, C, D, E>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final <E> QuadConstraintStream<A, B, C, D> ifNotExists(Class<E> otherClass, PentaJoiner<A, B, C, D, E>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
@Override
public final <E> QuadConstraintStream<A, B, C, D> ifNotExistsIncludingUnassigned(Class<E> otherClass,
PentaJoiner<A, B, C, D, E>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <E> QuadConstraintStream<A, B, C, D> ifNotExists(UniConstraintStream<E> otherStream,
PentaJoiner<A, B, C, D, E>... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <E> QuadConstraintStream<A, B, C, D> ifExistsOrNot(boolean shouldExist,
UniConstraintStream<E> otherStream, PentaJoiner<A, B, C, D, E>[] joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, E>) otherStream;
var joinerComber = PentaJoinerComber.comb(joiners);
var parentBridgeD = other.shareAndAddChild(new BavetForeBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsQuadConstraintStream<>(constraintFactory, this, parentBridgeD,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor =
zeroKeysGroupBy(collector, Group0Mapping1CollectorQuadNode::new);
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
var stream = shareAndAddChild(new BavetUniGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, Group0Mapping2CollectorQuadNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BavetBiGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, Group0Mapping3CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
var stream = shareAndAddChild(new BavetTriGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(QuadConstraintCollector<A, B, C, D, ResultContainerA_, ResultA_> collectorA,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, collectorD, Group0Mapping4CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
var stream = shareAndAddChild(new BavetQuadGroupQuadConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, Group1Mapping0CollectorQuadNode::new);
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_> groupBy(QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, Group1Mapping2CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerB_, ResultB_> collectorB,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, collectorD, Group1Mapping3CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
QuadFunction<A, B, C, D, GroupKey_> groupKeyMapping,
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collector, Group1Mapping1CollectorQuadNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorQuadNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_> groupBy(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collector, Group2Mapping1CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerC_, ResultC_> collectorC,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collectorC, collectorD,
Group2Mapping2CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping, QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, Group3Mapping0CollectorQuadNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping,
QuadConstraintCollector<A, B, C, D, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, collectorD,
Group3Mapping1CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(QuadFunction<A, B, C, D, GroupKeyA_> groupKeyAMapping,
QuadFunction<A, B, C, D, GroupKeyB_> groupKeyBMapping,
QuadFunction<A, B, C, D, GroupKeyC_> groupKeyCMapping,
QuadFunction<A, B, C, D, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
fourKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping,
Group4Mapping0CollectorQuadNode::new);
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public QuadConstraintStream<A, B, C, D> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(ConstantLambdaUtils.quadPickFirst(),
ConstantLambdaUtils.quadPickSecond(),
ConstantLambdaUtils.quadPickThird(),
ConstantLambdaUtils.quadPickFourth());
}
}
@Override
public QuadConstraintStream<A, B, C, D> concat(UniConstraintStream<A> otherStream) {
var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public QuadConstraintStream<A, B, C, D> concat(BiConstraintStream<A, B> otherStream) {
var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public QuadConstraintStream<A, B, C, D> concat(TriConstraintStream<A, B, C> otherStream) {
var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public QuadConstraintStream<A, B, C, D> concat(QuadConstraintStream<A, B, C, D> otherStream) {
var other = (BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>) otherStream;
var leftBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public <ResultA_> UniConstraintStream<ResultA_> map(QuadFunction<A, B, C, D, ResultA_> mapping) {
var stream = shareAndAddChild(new BavetUniMapQuadConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_> BiConstraintStream<ResultA_, ResultB_> map(QuadFunction<A, B, C, D, ResultA_> mappingA,
QuadFunction<A, B, C, D, ResultB_> mappingB) {
var stream = shareAndAddChild(new BavetBiMapQuadConstraintStream<>(constraintFactory, this, mappingA, mappingB));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_> TriConstraintStream<ResultA_, ResultB_, ResultC_> map(
QuadFunction<A, B, C, D, ResultA_> mappingA, QuadFunction<A, B, C, D, ResultB_> mappingB,
QuadFunction<A, B, C, D, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapQuadConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_> map(
QuadFunction<A, B, C, D, ResultA_> mappingA, QuadFunction<A, B, C, D, ResultB_> mappingB,
QuadFunction<A, B, C, D, ResultC_> mappingC, QuadFunction<A, B, C, D, ResultD_> mappingD) {
var stream = shareAndAddChild(
new BavetQuadMapQuadConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC, mappingD));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultD_> QuadConstraintStream<A, B, C, ResultD_> flattenLast(Function<D, Iterable<ResultD_>> mapping) {
var stream = shareAndAddChild(new BavetFlattenLastQuadConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> QuadConstraintBuilderImpl<A, B, C, D, Score_> newTerminator(
BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new QuadConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName, constraintWeight_,
impactType_, justificationMapping, indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringQuadConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final PentaFunction<A, B, C, D, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return InnerQuadConstraintStream.createDefaultJustificationMapping();
}
@Override
protected final QuadFunction<A, B, C, D, Collection<?>> getDefaultIndictedObjectsMapping() {
return InnerQuadConstraintStream.createDefaultIndictedObjectsMapping();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetBiGroupQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetBiGroupQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetBiGroupQuadConstraintStream<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "BiGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetBiMapQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetBiMapQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapQuadToBiNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetBiMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?> that = (BavetBiMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetConcatQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.score.Score;
public final class BavetConcatQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final ConcatNodeConstructor<A, B, C, D> nodeConstructor;
public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatUniQuadNode::new;
}
public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatBiQuadNode::new;
}
public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatTriQuadNode::new;
}
public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, A> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatQuadUniNode::new;
}
public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatQuadBiNode::new;
}
public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatQuadTriNode::new;
}
public BavetConcatQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> leftParent,
BavetForeBridgeQuadConstraintStream<Solution_, A, B, C, D> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatQuadQuadNode::new;
}
@Override
public boolean guaranteesDistinct() {
if (leftParent instanceof BavetAbstractQuadConstraintStream<Solution_, ?, ?, ?, ?>
&& rightParent instanceof BavetAbstractQuadConstraintStream<Solution_, ?, ?, ?, ?>) {
// The two parents could have the same source; guarantee impossible.
return false;
}
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetConcatQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetConcatQuadConstraintStream<?, ?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "Concat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C, D> {
AbstractConcatNode<?, ?, ?> apply(TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
int leftCloneStoreIndex, int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetFilterQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
final class BavetFilterQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadPredicate<A, B, C, D> predicate;
public BavetFilterQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadPredicate<A, B, C, D> predicate) {
super(constraintFactory, parent);
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
buildHelper.<QuadTuple<A, B, C, D>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalQuadTupleLifecycle<>(predicate, tupleLifecycle));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterQuadConstraintStream other) {
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetFlattenLastQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.core.api.score.Score;
final class BavetFlattenLastQuadConstraintStream<Solution_, A, B, C, D, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final Function<D, Iterable<NewD>> mappingFunction;
private BavetAftBridgeQuadConstraintStream<Solution_, A, B, C, NewD> flattenLastStream;
public BavetFlattenLastQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
Function<D, Iterable<NewD>> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, A, B, C, NewD> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
var node = new FlattenLastQuadNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetFlattenLastQuadConstraintStream<?, ?, ?, ?, ?, ?> that =
(BavetFlattenLastQuadConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "FlattenLast()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetIfExistsQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetIfExistsConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.common.penta.DefaultPentaJoiner;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.score.Score;
final class BavetIfExistsQuadConstraintStream<Solution_, A, B, C, D, E>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetIfExistsConstraintStream<Solution_> {
private final BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD;
private final BavetForeBridgeUniConstraintStream<Solution_, E> parentBridgeE;
private final boolean shouldExist;
private final DefaultPentaJoiner<A, B, C, D, E> joiner;
private final PentaPredicate<A, B, C, D, E> filtering;
public BavetIfExistsQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parentABCD,
BavetForeBridgeUniConstraintStream<Solution_, E> parentBridgeE,
boolean shouldExist,
DefaultPentaJoiner<A, B, C, D, E> joiner, PentaPredicate<A, B, C, D, E> filtering) {
super(constraintFactory, parentABCD.getRetrievalSemantics());
this.parentABCD = parentABCD;
this.parentBridgeE = parentBridgeE;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABCD.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABCD.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeE.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABCD.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<E> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsQuadNode<>(shouldExist,
indexerFactory.buildQuadLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsQuadNode<>(shouldExist,
indexerFactory.buildQuadLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
filtering))
: (filtering == null ? new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()), downstream)
: new UnindexedIfExistsQuadNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABCD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeE.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, this, parentBridgeE);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetIfExistsQuadConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetIfExistsQuadConstraintStream<?, ?, ?, ?, ?, ?>) object;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this ifExists node comes from.
*/
return shouldExist == that.shouldExist && Objects.equals(parentABCD,
that.parentABCD) && Objects.equals(
parentBridgeE.getParent(), that.parentBridgeE.getParent())
&& Objects.equals(joiner,
that.joiner)
&& Objects.equals(
filtering, that.filtering);
}
@Override
public int hashCode() {
return Objects.hash(parentABCD, parentBridgeE.getParent(), shouldExist, joiner, filtering);
}
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return parentABCD;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return parentBridgeE;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetJoinQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.common.quad.DefaultQuadJoiner;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
public final class BavetJoinQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetJoinConstraintStream<Solution_> {
private final BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent;
private final BavetForeBridgeUniConstraintStream<Solution_, D> rightParent;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetJoinQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, D> rightParent,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<QuadTuple<A, B, C, D>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<D> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? new IndexedJoinQuadNode<>(
indexerFactory.buildTriLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1,
indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new UnindexedJoinQuadNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinQuadConstraintStream<?, ?, ?, ?, ?> other = (BavetJoinQuadConstraintStream<?, ?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this join node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent())
&& Objects.equals(joiner, other.joiner)
&& Objects.equals(filtering, other.filtering);
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent(), joiner, filtering);
}
@Override
public String toString() {
return "QuadJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetQuadGroupQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetQuadGroupQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetQuadGroupQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "QuadGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetQuadMapQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetQuadMapQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC, NewD>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private final QuadFunction<A, B, C, D, NewC> mappingFunctionC;
private final QuadFunction<A, B, C, D, NewD> mappingFunctionD;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB, QuadFunction<A, B, C, D, NewC> mappingFunctionC,
QuadFunction<A, B, C, D, NewD> mappingFunctionD) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.mappingFunctionD = mappingFunctionD;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node =
new MapQuadToQuadNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetQuadMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?, ?> that =
(BavetQuadMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC,
that.mappingFunctionC)
&& Objects.equals(mappingFunctionD, that.mappingFunctionD);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "QuadMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetScoringQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.math.BigDecimal;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraint;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.common.inliner.ConstraintMatchSupplier;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.constraint.streams.common.inliner.WeightedScoreImpacter;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetScoringQuadConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>
implements BavetScoringConstraintStream<Solution_> {
private final ToIntQuadFunction<A, B, C, D> intMatchWeigher;
private final ToLongQuadFunction<A, B, C, D> longMatchWeigher;
private final QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, ToIntQuadFunction<A, B, C, D> intMatchWeigher) {
this(constraintFactory, parent, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, ToLongQuadFunction<A, B, C, D> longMatchWeigher) {
this(constraintFactory, parent, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, ToIntQuadFunction<A, B, C, D> intMatchWeigher,
ToLongQuadFunction<A, B, C, D> longMatchWeigher, QuadFunction<A, B, C, D, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent);
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
var constraintMatchEnabled = buildHelper.getScoreInliner().isConstraintMatchEnabled();
var scoreImpacter = constraintMatchEnabled ? buildScoreImpacterWithConstraintMatch() : buildScoreImpacter();
var weightedScoreImpacter = buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint);
var scorer = new QuadScorer<>(weightedScoreImpacter, scoreImpacter,
buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
private PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> buildScoreImpacter() {
if (intMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c, d);
return impacter.impactScore(matchWeight, null);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c, d);
return impacter.impactScore(matchWeight, null);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c, d);
return impacter.impactScore(matchWeight, null);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> buildScoreImpacterWithConstraintMatch() {
if (intMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c, d);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c, d);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c, d);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c, d);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c, d) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c, d);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c, d);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private static <A, B, C, D, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight, A a, B b, C c, D d) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, D, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c, d);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, D, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight, A a, B b, C c, D d) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, D, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c, d);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, D, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight, A a, B b, C c, D d) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, D, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c, d);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintRef() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetTriGroupQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetTriGroupQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetTriGroupQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "TriGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetTriMapQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetTriMapQuadConstraintStream<Solution_, A, B, C, D, NewA, NewB, NewC>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunctionA;
private final QuadFunction<A, B, C, D, NewB> mappingFunctionB;
private final QuadFunction<A, B, C, D, NewC> mappingFunctionC;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunctionA,
QuadFunction<A, B, C, D, NewB> mappingFunctionB, QuadFunction<A, B, C, D, NewC> mappingFunctionC) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapQuadToTriNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetTriMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?> that =
(BavetTriMapQuadConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB) && Objects.equals(mappingFunctionC, that.mappingFunctionC);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "TriMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetUniGroupQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetUniGroupQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniGroupQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent,
GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetUniGroupQuadConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "UniGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/BavetUniMapQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetUniMapQuadConstraintStream<Solution_, A, B, C, D, NewA>
extends BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> {
private final QuadFunction<A, B, C, D, NewA> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniMapQuadConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractQuadConstraintStream<Solution_, A, B, C, D> parent, QuadFunction<A, B, C, D, NewA> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapQuadToUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetUniMapQuadConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetUniMapQuadConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConcatBiQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatBiQuadNode<A, B, C, D>
extends AbstractConcatNode<BiTuple<A, B>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
ConcatBiQuadNode(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(BiTuple<A, B> leftTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, null, null, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConcatQuadBiNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatQuadBiNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, BiTuple<A, B>, QuadTuple<A, B, C, D>> {
ConcatQuadBiNode(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(BiTuple<A, B> rightTuple) {
return new QuadTuple<>(rightTuple.factA, rightTuple.factB, null, null, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConcatQuadQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatQuadQuadNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConcatQuadTriNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatQuadTriNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, TriTuple<A, B, C>, QuadTuple<A, B, C, D>> {
ConcatQuadTriNode(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(TriTuple<A, B, C> rightTuple) {
return new QuadTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, null, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConcatQuadUniNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class ConcatQuadUniNode<A, B, C, D>
extends AbstractConcatNode<QuadTuple<A, B, C, D>, UniTuple<A>, QuadTuple<A, B, C, D>> {
ConcatQuadUniNode(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(UniTuple<A> rightTuple) {
return new QuadTuple<>(rightTuple.factA, null, null, null, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConcatTriQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatTriQuadNode<A, B, C, D>
extends AbstractConcatNode<TriTuple<A, B, C>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
ConcatTriQuadNode(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(TriTuple<A, B, C> leftTuple) {
return new QuadTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, null, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConcatUniQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class ConcatUniQuadNode<A, B, C, D>
extends AbstractConcatNode<UniTuple<A>, QuadTuple<A, B, C, D>, QuadTuple<A, B, C, D>> {
ConcatUniQuadNode(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(UniTuple<A> leftTuple) {
return new QuadTuple<>(leftTuple.factA, null, null, null, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/ConditionalQuadTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractConditionalTupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadPredicate;
final class ConditionalQuadTupleLifecycle<A, B, C, D> extends AbstractConditionalTupleLifecycle<QuadTuple<A, B, C, D>> {
private final QuadPredicate<A, B, C, D> predicate;
public ConditionalQuadTupleLifecycle(QuadPredicate<A, B, C, D> predicate,
TupleLifecycle<QuadTuple<A, B, C, D>> tupleLifecycle) {
super(tupleLifecycle);
this.predicate = predicate;
}
@Override
protected boolean test(QuadTuple<A, B, C, D> tuple) {
return predicate.test(tuple.factA, tuple.factB, tuple.factC, tuple.factD);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/FlattenLastQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class FlattenLastQuadNode<A, B, C, D, NewD>
extends AbstractFlattenLastNode<QuadTuple<A, B, C, D>, QuadTuple<A, B, C, NewD>, D, NewD> {
private final int outputStoreSize;
FlattenLastQuadNode(int flattenLastStoreIndex, Function<D, Iterable<NewD>> mappingFunction,
TupleLifecycle<QuadTuple<A, B, C, NewD>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, NewD> createTuple(QuadTuple<A, B, C, D> originalTuple, NewD newD) {
return new 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group0Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group0Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, ResultContainer_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, UniTuple<A>, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group0Mapping2CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group0Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<A, B>, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group0Mapping3CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group0Mapping4CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group0Mapping4CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group1Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, UniTuple<A>, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group1Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group1Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, ResultContainer_>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainer_, B> collector,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group1Mapping2CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group1Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class 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 -> 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group1Mapping3CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group0Mapping3CollectorQuadNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group1Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group1Mapping3CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerB_, B> collectorB,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex, tuple -> createGroupKey(groupKeyMapping, tuple),
mergeCollectors(collectorB, collectorC, collectorD), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group2Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B>
extends AbstractGroupQuadNode<OldA, OldB, OldC, OldD, BiTuple<A, B>, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group2Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group2Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class 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 -> 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group2Mapping2CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group0Mapping2CollectorQuadNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group2Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping2CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerC_, C> collectorC,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple),
mergeCollectors(collectorC, collectorD), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group3Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, TriTuple<A, B, C>, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group3Mapping1CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import static ai.timefold.solver.constraint.streams.bavet.quad.Group3Mapping0CollectorQuadNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping1CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D, ResultContainer_>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, Triple<A, B, C>, ResultContainer_, D> {
private final int outputStoreSize;
public Group3Mapping1CollectorQuadNode(QuadFunction<OldA, OldB, OldC, OldD, A> groupKeyMappingA,
QuadFunction<OldA, OldB, OldC, OldD, B> groupKeyMappingB, QuadFunction<OldA, OldB, OldC, OldD, C> groupKeyMappingC,
int groupStoreIndex, int undoStoreIndex,
QuadConstraintCollector<OldA, OldB, OldC, OldD, ResultContainer_, D> collector,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/Group4Mapping0CollectorQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group4Mapping0CollectorQuadNode<OldA, OldB, OldC, OldD, A, B, C, D>
extends
AbstractGroupQuadNode<OldA, OldB, OldC, OldD, QuadTuple<A, B, C, D>, 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/IndexedIfExistsQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractIndexedIfExistsNode;
import ai.timefold.solver.constraint.streams.bavet.common.ExistsCounter;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.function.QuadFunction;
final class IndexedIfExistsQuadNode<A, B, C, D, E> extends AbstractIndexedIfExistsNode<QuadTuple<A, B, C, D>, E> {
private final QuadFunction<A, B, C, D, IndexProperties> mappingABCD;
private final PentaPredicate<A, B, C, D, E> filtering;
public IndexedIfExistsQuadNode(boolean shouldExist,
QuadFunction<A, B, C, D, IndexProperties> mappingABCD, Function<E, IndexProperties> mappingE,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightProperties,
int inputStoreIndexRightEntry,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<QuadTuple<A, B, C, D>>> indexerABCD, Indexer<UniTuple<E>> indexerE) {
this(shouldExist, mappingABCD, mappingE,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightProperties,
inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, indexerABCD, indexerE,
null);
}
public IndexedIfExistsQuadNode(boolean shouldExist,
QuadFunction<A, B, C, D, IndexProperties> mappingABCD, Function<E, IndexProperties> mappingE,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<QuadTuple<A, B, C, D>>> indexerABCD, Indexer<UniTuple<E>> indexerE,
PentaPredicate<A, B, C, D, E> filtering) {
super(shouldExist, mappingE,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightProperties, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, indexerABCD, indexerE,
filtering != null);
this.mappingABCD = mappingABCD;
this.filtering = filtering;
}
@Override
protected IndexProperties createIndexProperties(QuadTuple<A, B, C, D> leftTuple) {
return mappingABCD.apply(leftTuple.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD);
}
@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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/IndexedJoinQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractIndexedJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.function.TriFunction;
final class IndexedJoinQuadNode<A, B, C, D>
extends AbstractIndexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>> {
private final TriFunction<A, B, C, IndexProperties> mappingABC;
private final QuadPredicate<A, B, C, D> filtering;
private final int outputStoreSize;
public IndexedJoinQuadNode(TriFunction<A, B, C, IndexProperties> mappingABC, Function<D, IndexProperties> mappingD,
int inputStoreIndexABC, int inputStoreIndexEntryABC, int inputStoreIndexOutTupleListABC,
int inputStoreIndexD, int inputStoreIndexEntryD, int inputStoreIndexOutTupleListD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, QuadPredicate<A, B, C, D> filtering,
int outputStoreSize,
int outputStoreIndexOutEntryABC, int outputStoreIndexOutEntryD,
Indexer<TriTuple<A, B, C>> indexerABC,
Indexer<UniTuple<D>> indexerD) {
super(mappingD,
inputStoreIndexABC, inputStoreIndexEntryABC, inputStoreIndexOutTupleListABC,
inputStoreIndexD, inputStoreIndexEntryD, inputStoreIndexOutTupleListD,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexOutEntryABC, outputStoreIndexOutEntryD,
indexerABC, indexerD);
this.mappingABC = mappingABC;
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected IndexProperties createIndexPropertiesLeft(TriTuple<A, B, C> leftTuple) {
return mappingABC.apply(leftTuple.factA, leftTuple.factB, leftTuple.factC);
}
@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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/MapQuadToBiNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
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;
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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/MapQuadToQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
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;
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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/MapQuadToTriNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
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;
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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/MapQuadToUniNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.function.QuadFunction;
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;
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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/QuadScorer.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractScorer;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.constraint.streams.common.inliner.WeightedScoreImpacter;
import ai.timefold.solver.core.api.function.PentaFunction;
final class QuadScorer<A, B, C, D> extends AbstractScorer<QuadTuple<A, B, C, D>> {
private final PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> scoreImpacter;
public QuadScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter,
PentaFunction<WeightedScoreImpacter<?, ?>, A, B, C, D, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(weightedScoreImpacter, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(QuadTuple<A, B, C, D> tuple) {
try {
return scoreImpacter.apply(weightedScoreImpacter, tuple.factA, tuple.factB, tuple.factC, tuple.factD);
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/UnindexedIfExistsQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedIfExistsNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.function.PentaPredicate;
final class UnindexedIfExistsQuadNode<A, B, C, D, E> extends AbstractUnindexedIfExistsNode<QuadTuple<A, B, C, D>, E> {
private final PentaPredicate<A, B, C, D, E> filtering;
public UnindexedIfExistsQuadNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightEntry,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle) {
this(shouldExist,
inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public UnindexedIfExistsQuadNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList, int inputStoreIndexRightEntry,
int inputStoreIndexRightTrackerList,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle,
PentaPredicate<A, B, C, D, E> filtering) {
super(shouldExist,
inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList, inputStoreIndexRightEntry,
inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(QuadTuple<A, B, C, D> leftTuple, UniTuple<E> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, leftTuple.factC, leftTuple.factD,
rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/quad/UnindexedJoinQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.quad;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.function.QuadPredicate;
final class UnindexedJoinQuadNode<A, B, C, D>
extends AbstractUnindexedJoinNode<TriTuple<A, B, C>, D, QuadTuple<A, B, C, D>> {
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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/AbstractGroupTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractGroupNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
abstract class AbstractGroupTriNode<OldA, OldB, OldC, OutTuple_ extends 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-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetAbstractTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.fourKeysGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.oneKeyGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.threeKeysGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.twoKeysGroupBy;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.zeroKeysGroupBy;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetAbstractQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetConcatQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetJoinQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.uni.BavetAbstractUniConstraintStream;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.constraint.streams.common.quad.QuadJoinerComber;
import ai.timefold.solver.constraint.streams.common.tri.InnerTriConstraintStream;
import ai.timefold.solver.constraint.streams.common.tri.TriConstraintBuilderImpl;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
public abstract class BavetAbstractTriConstraintStream<Solution_, A, B, C> extends BavetAbstractConstraintStream<Solution_>
implements InnerTriConstraintStream<A, B, C> {
protected BavetAbstractTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
protected BavetAbstractTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public BavetAbstractTriConstraintStream<Solution_, A, B, C> filter(TriPredicate<A, B, C> predicate) {
return shareAndAddChild(new BavetFilterTriConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// Join
// ************************************************************************
@Override
@SafeVarargs
public final <D> QuadConstraintStream<A, B, C, D> join(UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>... joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, D>) otherStream;
var joinerComber = QuadJoinerComber.comb(joiners);
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var joinStream = new BavetJoinQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge,
joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering());
return constraintFactory.share(joinStream, joinStream_ -> {
// Connect the bridges upstream, as it is an actual new join.
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final <D> TriConstraintStream<A, B, C> ifExists(Class<D> otherClass, QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
@Override
public final <D> TriConstraintStream<A, B, C> ifExistsIncludingUnassigned(Class<D> otherClass,
QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <D> TriConstraintStream<A, B, C> ifExists(UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final <D> TriConstraintStream<A, B, C> ifNotExists(Class<D> otherClass, QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
@Override
public final <D> TriConstraintStream<A, B, C> ifNotExistsIncludingUnassigned(Class<D> otherClass,
QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <D> TriConstraintStream<A, B, C> ifNotExists(UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <D> TriConstraintStream<A, B, C> ifExistsOrNot(boolean shouldExist, UniConstraintStream<D> otherStream,
QuadJoiner<A, B, C, D>[] joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, D>) otherStream;
var joinerComber = QuadJoinerComber.comb(joiners);
var parentBridgeD = other.shareAndAddChild(new BavetForeBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsTriConstraintStream<>(constraintFactory, this, parentBridgeD,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor =
zeroKeysGroupBy(collector, Group0Mapping1CollectorTriNode::new);
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA>
buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
var stream = shareAndAddChild(new BavetUniGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, Group0Mapping2CollectorTriNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BavetBiGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, Group0Mapping3CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
var stream = shareAndAddChild(new BavetTriGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(TriConstraintCollector<A, B, C, ResultContainerA_, ResultA_> collectorA,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, collectorD, Group0Mapping4CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
var stream = shareAndAddChild(new BavetQuadGroupTriConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(TriFunction<A, B, C, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, Group1Mapping0CollectorTriNode::new);
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_> groupBy(TriFunction<A, B, C, GroupKey_> groupKeyMapping,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, Group1Mapping2CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(TriFunction<A, B, C, GroupKey_> groupKeyMapping,
TriConstraintCollector<A, B, C, ResultContainerB_, ResultB_> collectorB,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, collectorD, Group1Mapping3CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
TriFunction<A, B, C, GroupKey_> groupKeyMapping,
TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collector, Group1Mapping1CollectorTriNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorTriNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_> groupBy(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriConstraintCollector<A, B, C, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collector, Group2Mapping1CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriConstraintCollector<A, B, C, ResultContainerC_, ResultC_> collectorC,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collectorC, collectorD, Group2Mapping2CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping, TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, Group3Mapping0CollectorTriNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping,
TriConstraintCollector<A, B, C, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, collectorD,
Group3Mapping1CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(TriFunction<A, B, C, GroupKeyA_> groupKeyAMapping,
TriFunction<A, B, C, GroupKeyB_> groupKeyBMapping,
TriFunction<A, B, C, GroupKeyC_> groupKeyCMapping,
TriFunction<A, B, C, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
fourKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping,
Group4Mapping0CollectorTriNode::new);
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public TriConstraintStream<A, B, C> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(ConstantLambdaUtils.triPickFirst(),
ConstantLambdaUtils.triPickSecond(),
ConstantLambdaUtils.triPickThird());
}
}
@Override
public TriConstraintStream<A, B, C> concat(UniConstraintStream<A> otherStream) {
var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public TriConstraintStream<A, B, C> concat(BiConstraintStream<A, B> otherStream) {
var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public TriConstraintStream<A, B, C> concat(TriConstraintStream<A, B, C> otherStream) {
var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatTriConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public <D> QuadConstraintStream<A, B, C, D> concat(QuadConstraintStream<A, B, C, D> otherStream) {
var other = (BavetAbstractQuadConstraintStream<Solution_, A, B, C, D>) otherStream;
var leftBridge = new BavetForeBridgeTriConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeQuadConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatQuadConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public <ResultA_> UniConstraintStream<ResultA_> map(TriFunction<A, B, C, ResultA_> mapping) {
var stream = shareAndAddChild(new BavetUniMapTriConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_> BiConstraintStream<ResultA_, ResultB_> map(TriFunction<A, B, C, ResultA_> mappingA,
TriFunction<A, B, C, ResultB_> mappingB) {
var stream = shareAndAddChild(new BavetBiMapTriConstraintStream<>(constraintFactory, this, mappingA, mappingB));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_> TriConstraintStream<ResultA_, ResultB_, ResultC_> map(
TriFunction<A, B, C, ResultA_> mappingA, TriFunction<A, B, C, ResultB_> mappingB,
TriFunction<A, B, C, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapTriConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_> map(
TriFunction<A, B, C, ResultA_> mappingA, TriFunction<A, B, C, ResultB_> mappingB,
TriFunction<A, B, C, ResultC_> mappingC, TriFunction<A, B, C, ResultD_> mappingD) {
var stream = shareAndAddChild(new BavetQuadMapTriConstraintStream<>(constraintFactory, this, mappingA, mappingB,
mappingC, mappingD, false));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultC_> TriConstraintStream<A, B, ResultC_> flattenLast(Function<C, Iterable<ResultC_>> mapping) {
var stream = shareAndAddChild(new BavetFlattenLastTriConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Other operations
// ************************************************************************
@Override
public <ResultD_> QuadConstraintStream<A, B, C, ResultD_> expand(TriFunction<A, B, C, ResultD_> mapping) {
var stream = shareAndAddChild(new BavetQuadMapTriConstraintStream<>(constraintFactory, this,
ConstantLambdaUtils.triPickFirst(),
ConstantLambdaUtils.triPickSecond(),
ConstantLambdaUtils.triPickThird(), mapping, true));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> TriConstraintBuilderImpl<A, B, C, Score_>
newTerminator(BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new TriConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping) -> buildConstraint(constraintPackage, constraintName, constraintWeight_,
impactType_, justificationMapping, indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringTriConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final QuadFunction<A, B, C, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return InnerTriConstraintStream.createDefaultJustificationMapping();
}
@Override
protected final TriFunction<A, B, C, Collection<?>> getDefaultIndictedObjectsMapping() {
return InnerTriConstraintStream.createDefaultIndictedObjectsMapping();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetBiGroupTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetBiGroupTriConstraintStream<Solution_, A, B, C, NewA, NewB>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetBiGroupTriConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "BiGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetBiMapTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetBiMapTriConstraintStream<Solution_, A, B, C, NewA, NewB>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapTriToBiNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetBiMapTriConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetBiMapTriConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetConcatTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetConcatConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.score.Score;
public final class BavetConcatTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetConcatConstraintStream<Solution_> {
private final BavetAbstractConstraintStream<Solution_> leftParent;
private final BavetAbstractConstraintStream<Solution_> rightParent;
private final ConcatNodeConstructor<A, B, C> nodeConstructor;
public BavetConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatUniTriNode::new;
}
public BavetConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatBiTriNode::new;
}
public BavetConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, A> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatTriUniNode::new;
}
public BavetConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeBiConstraintStream<Solution_, A, B> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatTriBiNode::new;
}
public BavetConcatTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> leftParent,
BavetForeBridgeTriConstraintStream<Solution_, A, B, C> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.nodeConstructor = ConcatTriTriNode::new;
}
@Override
public boolean guaranteesDistinct() {
if (leftParent instanceof BavetAbstractTriConstraintStream<Solution_, ?, ?, ?>
&& rightParent instanceof BavetAbstractTriConstraintStream<Solution_, ?, ?, ?>) {
// The two parents could have the same source; guarantee impossible.
return false;
}
/*
* Since one of the two parents is increasing in cardinality,
* it means its tuples must be distinct from the other parent's tuples.
* Therefore, the guarantee can be given is both of the parents give it.
*/
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = nodeConstructor.apply(downstream, leftCloneStoreIndex, rightCloneStoreIndex, outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetConcatTriConstraintStream<?, ?, ?, ?> other = (BavetConcatTriConstraintStream<?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this concat node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent());
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent());
}
@Override
public String toString() {
return "Concat() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
private interface ConcatNodeConstructor<A, B, C> {
AbstractConcatNode<?, ?, ?> apply(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int leftCloneStoreIndex,
int rightCloneStoreIndex, int outputStoreSize);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetFilterTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
final class BavetFilterTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriPredicate<A, B, C> predicate;
public BavetFilterTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriPredicate<A, B, C> predicate) {
super(constraintFactory, parent);
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
buildHelper.<TriTuple<A, B, C>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalTriTupleLifecycle<>(predicate, tupleLifecycle));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return Objects.hash(parent, predicate);
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetFilterTriConstraintStream other) {
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetFlattenLastTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.core.api.score.Score;
final class BavetFlattenLastTriConstraintStream<Solution_, A, B, C, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final Function<C, Iterable<NewC>> mappingFunction;
private BavetAftBridgeTriConstraintStream<Solution_, A, B, NewC> flattenLastStream;
public BavetFlattenLastTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
Function<C, Iterable<NewC>> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, A, B, NewC> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
var node = new FlattenLastTriNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetFlattenLastTriConstraintStream<?, ?, ?, ?, ?> that = (BavetFlattenLastTriConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "FlattenLast()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetIfExistsTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetIfExistsConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.common.quad.DefaultQuadJoiner;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.Score;
final class BavetIfExistsTriConstraintStream<Solution_, A, B, C, D>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetIfExistsConstraintStream<Solution_> {
private final BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC;
private final BavetForeBridgeUniConstraintStream<Solution_, D> parentBridgeD;
private final boolean shouldExist;
private final DefaultQuadJoiner<A, B, C, D> joiner;
private final QuadPredicate<A, B, C, D> filtering;
public BavetIfExistsTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parentABC,
BavetForeBridgeUniConstraintStream<Solution_, D> parentBridgeD,
boolean shouldExist,
DefaultQuadJoiner<A, B, C, D> joiner, QuadPredicate<A, B, C, D> filtering) {
super(constraintFactory, parentABC.getRetrievalSemantics());
this.parentABC = parentABC;
this.parentBridgeD = parentBridgeD;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentABC.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentABC.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeD.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentABC.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<D> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsTriNode<>(shouldExist,
indexerFactory.buildTriLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsTriNode<>(shouldExist,
indexerFactory.buildTriLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
filtering))
: (filtering == null ? new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()), downstream)
: new UnindexedIfExistsTriNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentABC.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeD.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, this, parentBridgeD);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetIfExistsTriConstraintStream<?, ?, ?, ?, ?> that = (BavetIfExistsTriConstraintStream<?, ?, ?, ?, ?>) object;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this ifExists node comes from.
*/
return shouldExist == that.shouldExist && Objects.equals(parentABC,
that.parentABC) && Objects.equals(
parentBridgeD.getParent(), that.parentBridgeD.getParent())
&& Objects.equals(joiner,
that.joiner)
&& Objects.equals(
filtering, that.filtering);
}
@Override
public int hashCode() {
return Objects.hash(parentABC, parentBridgeD.getParent(), shouldExist, joiner, filtering);
}
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return parentABC;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return parentBridgeD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetJoinTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetForeBridgeUniConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.common.tri.DefaultTriJoiner;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.Score;
public final class BavetJoinTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetJoinConstraintStream<Solution_> {
private final BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent;
private final BavetForeBridgeUniConstraintStream<Solution_, C> rightParent;
private final DefaultTriJoiner<A, B, C> joiner;
private final TriPredicate<A, B, C> filtering;
public BavetJoinTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeBiConstraintStream<Solution_, A, B> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, C> rightParent,
DefaultTriJoiner<A, B, C> joiner, TriPredicate<A, B, C> filtering) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return leftParent.guaranteesDistinct() && rightParent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
TupleLifecycle<TriTuple<A, B, C>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<C> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? new IndexedJoinTriNode<>(
indexerFactory.buildBiLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1,
indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new UnindexedJoinTriNode<>(
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource()),
downstream, filtering, outputStoreSize + 2,
outputStoreSize, outputStoreSize + 1);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetJoinTriConstraintStream<?, ?, ?, ?> other = (BavetJoinTriConstraintStream<?, ?, ?, ?>) o;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this join node comes from.
*/
return Objects.equals(leftParent.getParent(), other.leftParent.getParent())
&& Objects.equals(rightParent.getParent(), other.rightParent.getParent())
&& Objects.equals(joiner, other.joiner)
&& Objects.equals(filtering, other.filtering);
}
@Override
public int hashCode() {
return Objects.hash(leftParent.getParent(), rightParent.getParent(), joiner, filtering);
}
@Override
public String toString() {
return "TriJoin() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return leftParent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return rightParent;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetQuadGroupTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetQuadGroupTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC, NewD>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetQuadGroupTriConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "QuadGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetQuadMapTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeQuadConstraintStream;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetQuadMapTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC, NewD>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private final TriFunction<A, B, C, NewC> mappingFunctionC;
private final TriFunction<A, B, C, NewD> mappingFunctionD;
private final boolean guaranteesDistinct;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB, TriFunction<A, B, C, NewC> mappingFunctionC,
TriFunction<A, B, C, NewD> mappingFunctionD, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.mappingFunctionD = mappingFunctionD;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node =
new MapTriToQuadNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetQuadMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?, ?> that =
(BavetQuadMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC,
that.mappingFunctionC)
&& Objects.equals(mappingFunctionD, that.mappingFunctionD);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "QuadMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetScoringTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.math.BigDecimal;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraint;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.common.inliner.ConstraintMatchSupplier;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.constraint.streams.common.inliner.WeightedScoreImpacter;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetScoringTriConstraintStream<Solution_, A, B, C>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C>
implements BavetScoringConstraintStream<Solution_> {
private final ToIntTriFunction<A, B, C> intMatchWeigher;
private final ToLongTriFunction<A, B, C> longMatchWeigher;
private final TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, ToIntTriFunction<A, B, C> intMatchWeigher) {
this(constraintFactory, parent, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, ToLongTriFunction<A, B, C> longMatchWeigher) {
this(constraintFactory, parent, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, ToIntTriFunction<A, B, C> intMatchWeigher,
ToLongTriFunction<A, B, C> longMatchWeigher, TriFunction<A, B, C, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent);
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
var constraintMatchEnabled = buildHelper.getScoreInliner().isConstraintMatchEnabled();
var scoreImpacter = constraintMatchEnabled ? buildScoreImpacterWithConstraintMatch() : buildScoreImpacter();
var weightedScoreImpacter = buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint);
var scorer = new TriScorer<>(weightedScoreImpacter, scoreImpacter,
buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
private QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> buildScoreImpacter() {
if (intMatchWeigher != null) {
return (impacter, a, b, c) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c);
return impacter.impactScore(matchWeight, null);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c);
return impacter.impactScore(matchWeight, null);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c);
return impacter.impactScore(matchWeight, null);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> buildScoreImpacterWithConstraintMatch() {
if (intMatchWeigher != null) {
return (impacter, a, b, c) -> {
int matchWeight = intMatchWeigher.applyAsInt(a, b, c);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c);
};
} else if (longMatchWeigher != null) {
return (impacter, a, b, c) -> {
long matchWeight = longMatchWeigher.applyAsLong(a, b, c);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a, b, c) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a, b, c);
return impactWithConstraintMatch(impacter, matchWeight, a, b, c);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private static <A, B, C, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight, A a, B b, C c) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight, A a, B b, C c) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, B, C, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight, A a, B b, C c) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, B, C, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a, b, c);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintRef() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetTriGroupTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetTriGroupTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> aftStreamChildList = aftStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), aftStream, aftStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (BavetTriGroupTriConstraintStream<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "TriGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/bavet/tri/BavetTriMapTriConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.bridge.BavetAftBridgeTriConstraintStream;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetTriMapTriConstraintStream<Solution_, A, B, C, NewA, NewB, NewC>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private final TriFunction<A, B, C, NewC> mappingFunctionC;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB, TriFunction<A, B, C, NewC> mappingFunctionC) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapTriToTriNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetTriMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?> that = (BavetTriMapTriConstraintStream<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunctionA, that.mappingFunctionA) && Objects.equals(
mappingFunctionB,
that.mappingFunctionB) && Objects.equals(mappingFunctionC, that.mappingFunctionC);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "TriMap()";
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.