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/tri/BavetUniGroupTriConstraintStream.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.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 BavetUniGroupTriConstraintStream<Solution_, A, B, C, NewA>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniGroupTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(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 = (BavetUniGroupTriConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "UniGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/BavetUniMapTriConstraintStream.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.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
final class BavetUniMapTriConstraintStream<Solution_, A, B, C, NewA>
extends BavetAbstractTriConstraintStream<Solution_, A, B, C> {
private final TriFunction<A, B, C, NewA> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniMapTriConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractTriConstraintStream<Solution_, A, B, C> parent, TriFunction<A, B, C, NewA> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapTriToUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetUniMapTriConstraintStream<?, ?, ?, ?, ?> that = (BavetUniMapTriConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/ConcatBiTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatBiTriNode<A, B, C>
extends AbstractConcatNode<BiTuple<A, B>, TriTuple<A, B, C>, TriTuple<A, B, C>> {
ConcatBiTriNode(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(BiTuple<A, B> leftTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, null, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(TriTuple<A, B, C> rightTuple) {
return new TriTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(BiTuple<A, B> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
}
@Override
protected void updateOutTupleFromRight(TriTuple<A, B, C> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/ConcatTriBiNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatTriBiNode<A, B, C>
extends AbstractConcatNode<TriTuple<A, B, C>, BiTuple<A, B>, TriTuple<A, B, C>> {
ConcatTriBiNode(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(TriTuple<A, B, C> leftTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(BiTuple<A, B> rightTuple) {
return new TriTuple<>(rightTuple.factA, rightTuple.factB, null, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(TriTuple<A, B, C> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void updateOutTupleFromRight(BiTuple<A, B> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/ConcatTriTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class ConcatTriTriNode<A, B, C>
extends AbstractConcatNode<TriTuple<A, B, C>, TriTuple<A, B, C>, TriTuple<A, B, C>> {
ConcatTriTriNode(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(TriTuple<A, B, C> leftTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(TriTuple<A, B, C> rightTuple) {
return new TriTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(TriTuple<A, B, C> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void updateOutTupleFromRight(TriTuple<A, B, C> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/ConcatTriUniNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
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;
final class ConcatTriUniNode<A, B, C>
extends AbstractConcatNode<TriTuple<A, B, C>, UniTuple<A>, TriTuple<A, B, C>> {
ConcatTriUniNode(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(TriTuple<A, B, C> leftTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, leftTuple.factC, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(UniTuple<A> rightTuple) {
return new TriTuple<>(rightTuple.factA, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(TriTuple<A, B, C> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
outTuple.factC = leftTuple.factC;
}
@Override
protected void updateOutTupleFromRight(UniTuple<A> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/ConcatUniTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
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;
final class ConcatUniTriNode<A, B, C>
extends AbstractConcatNode<UniTuple<A>, TriTuple<A, B, C>, TriTuple<A, B, C>> {
ConcatUniTriNode(TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList,
outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromLeft(UniTuple<A> leftTuple) {
return new TriTuple<>(leftTuple.factA, null, null, outputStoreSize);
}
@Override
protected TriTuple<A, B, C> getOutTupleFromRight(TriTuple<A, B, C> rightTuple) {
return new TriTuple<>(rightTuple.factA, rightTuple.factB, rightTuple.factC, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(UniTuple<A> leftTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = leftTuple.factA;
}
@Override
protected void updateOutTupleFromRight(TriTuple<A, B, C> rightTuple, TriTuple<A, B, C> outTuple) {
outTuple.factA = rightTuple.factA;
outTuple.factB = rightTuple.factB;
outTuple.factC = rightTuple.factC;
}
}
|
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/ConditionalTriTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractConditionalTupleLifecycle;
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.TriPredicate;
final class ConditionalTriTupleLifecycle<A, B, C> extends AbstractConditionalTupleLifecycle<TriTuple<A, B, C>> {
private final TriPredicate<A, B, C> predicate;
public ConditionalTriTupleLifecycle(TriPredicate<A, B, C> predicate, TupleLifecycle<TriTuple<A, B, C>> tupleLifecycle) {
super(tupleLifecycle);
this.predicate = predicate;
}
@Override
protected boolean test(TriTuple<A, B, C> tuple) {
return predicate.test(tuple.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/FlattenLastTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
final class FlattenLastTriNode<A, B, C, NewC>
extends AbstractFlattenLastNode<TriTuple<A, B, C>, TriTuple<A, B, NewC>, C, NewC> {
private final int outputStoreSize;
FlattenLastTriNode(int flattenLastStoreIndex, Function<C, Iterable<NewC>> mappingFunction,
TupleLifecycle<TriTuple<A, B, NewC>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, NewC> createTuple(TriTuple<A, B, C> originalTuple, NewC newC) {
return new TriTuple<>(originalTuple.factA, originalTuple.factB, newC, outputStoreSize);
}
@Override
protected C getEffectiveFactIn(TriTuple<A, B, C> tuple) {
return tuple.factC;
}
@Override
protected NewC getEffectiveFactOut(TriTuple<A, B, NewC> outTuple) {
return outTuple.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/Group0Mapping1CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group0Mapping1CollectorTriNode<OldA, OldB, OldC, A, ResultContainer_>
extends AbstractGroupTriNode<OldA, OldB, OldC, UniTuple<A>, Void, ResultContainer_, A> {
private final int outputStoreSize;
public Group0Mapping1CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainer_, A> collector,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, collector, nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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/tri/Group0Mapping2CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group0Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, OldC, A, B, ResultContainerA_, ResultContainerB_>
TriConstraintCollector<OldA, OldB, OldC, Object, Pair<A, B>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB) {
return (TriConstraintCollector<OldA, OldB, OldC, Object, Pair<A, B>>) ConstraintCollectors.compose(collectorA,
collectorB,
Pair::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/tri/Group0Mapping3CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group0Mapping3CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB, collectorC),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, OldC, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
TriConstraintCollector<OldA, OldB, OldC, Object, Triple<A, B, C>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC) {
return (TriConstraintCollector<OldA, OldB, OldC, Object, Triple<A, B, C>>) ConstraintCollectors.compose(collectorA,
collectorB, collectorC, Triple::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/tri/Group0Mapping4CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group0Mapping4CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB, collectorC, collectorD),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, OldC, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
TriConstraintCollector<OldA, OldB, OldC, Object, Quadruple<A, B, C, D>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD) {
return (TriConstraintCollector<OldA, OldB, OldC, Object, Quadruple<A, B, C, D>>) ConstraintCollectors.compose(
collectorA, collectorB, collectorC, collectorD, Quadruple::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/tri/Group1Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping0CollectorTriNode<OldA, OldB, OldC, A>
extends AbstractGroupTriNode<OldA, OldB, OldC, UniTuple<A>, A, Void, Void> {
private final int outputStoreSize;
public Group1Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, OldA, OldB, OldC> A createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
TriTuple<OldA, OldB, OldC> tuple) {
return groupKeyMapping.apply(tuple.factA, tuple.factB, tuple.factC);
}
@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/tri/Group1Mapping1CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group1Mapping0CollectorTriNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, ResultContainer_>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainer_, B> collector,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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/tri/Group1Mapping2CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group1Mapping0CollectorTriNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group1Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, A, Object, Pair<B, C>> {
private final int outputStoreSize;
public Group1Mapping2CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorTriNode.mergeCollectors(collectorB, collectorC), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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/tri/Group1Mapping3CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group0Mapping3CollectorTriNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group1Mapping0CollectorTriNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group1Mapping3CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple),
mergeCollectors(collectorB, collectorC, collectorD), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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/tri/Group2Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
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.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping0CollectorTriNode<OldA, OldB, OldC, A, B>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, int groupStoreIndex,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, OldA, OldB, OldC> Pair<A, B> createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriTuple<OldA, OldB, OldC> tuple) {
OldA oldA = tuple.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
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/tri/Group2Mapping1CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group2Mapping0CollectorTriNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainer_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, Pair<A, B>, ResultContainer_, C> {
private final int outputStoreSize;
public Group2Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainer_, C> collector,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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/tri/Group2Mapping2CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group0Mapping2CollectorTriNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group2Mapping0CollectorTriNode.createGroupKey;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple),
mergeCollectors(collectorC, collectorD), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected 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/tri/Group3Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping0CollectorTriNode<OldA, OldB, OldC, A, B, C>
extends AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, 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> Triple<A, B, C> createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriTuple<OldA, OldB, OldC> tuple) {
OldA oldA = tuple.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
C c = groupKeyMappingC.apply(oldA, oldB, oldC);
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/tri/Group3Mapping1CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import static ai.timefold.solver.constraint.streams.bavet.tri.Group3Mapping0CollectorTriNode.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.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainer_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Triple<A, B, C>, ResultContainer_, D> {
private final int outputStoreSize;
public Group3Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, 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/tri/Group4Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group4Mapping0CollectorTriNode<OldA, OldB, OldC, A, B, C, D>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriFunction<OldA, OldB, OldC, 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> Quadruple<A, B, C, D> createGroupKey(
TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB,
TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriFunction<OldA, OldB, OldC, D> groupKeyMappingD,
TriTuple<OldA, OldB, OldC> tuple) {
OldA oldA = tuple.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
C c = groupKeyMappingC.apply(oldA, oldB, oldC);
D d = groupKeyMappingD.apply(oldA, oldB, oldC);
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/tri/IndexedIfExistsTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.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 IndexedIfExistsTriNode<A, B, C, D> extends AbstractIndexedIfExistsNode<TriTuple<A, B, C>, D> {
private final TriFunction<A, B, C, IndexProperties> mappingABC;
private final QuadPredicate<A, B, C, D> filtering;
public IndexedIfExistsTriNode(boolean shouldExist,
TriFunction<A, B, C, IndexProperties> mappingABC, Function<D, IndexProperties> mappingD,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightProperties,
int inputStoreIndexRightEntry,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<TriTuple<A, B, C>>> indexerABC, Indexer<UniTuple<D>> indexerD) {
this(shouldExist, mappingABC, mappingD,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightProperties,
inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, indexerABC, indexerD,
null);
}
public IndexedIfExistsTriNode(boolean shouldExist,
TriFunction<A, B, C, IndexProperties> mappingABC, Function<D, IndexProperties> mappingD,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<TriTuple<A, B, C>>> indexerABC, Indexer<UniTuple<D>> indexerD,
QuadPredicate<A, B, C, D> filtering) {
super(shouldExist, mappingD,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightProperties, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, indexerABC, indexerD,
filtering != null);
this.mappingABC = mappingABC;
this.filtering = filtering;
}
@Override
protected IndexProperties createIndexProperties(TriTuple<A, B, C> leftTuple) {
return mappingABC.apply(leftTuple.factA, leftTuple.factB, leftTuple.factC);
}
@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/IndexedJoinTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.function.BiFunction;
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.BiTuple;
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.TriPredicate;
final class IndexedJoinTriNode<A, B, C>
extends AbstractIndexedJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>> {
private final BiFunction<A, B, IndexProperties> mappingAB;
private final TriPredicate<A, B, C> filtering;
private final int outputStoreSize;
public IndexedJoinTriNode(BiFunction<A, B, IndexProperties> mappingAB, Function<C, IndexProperties> mappingC,
int inputStoreIndexAB, int inputStoreIndexEntryAB, int inputStoreIndexOutTupleListAB,
int inputStoreIndexC, int inputStoreIndexEntryC, int inputStoreIndexOutTupleListC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, TriPredicate<A, B, C> filtering,
int outputStoreSize,
int outputStoreIndexOutEntryAB, int outputStoreIndexOutEntryC,
Indexer<BiTuple<A, B>> indexerAB,
Indexer<UniTuple<C>> indexerC) {
super(mappingC,
inputStoreIndexAB, inputStoreIndexEntryAB, inputStoreIndexOutTupleListAB,
inputStoreIndexC, inputStoreIndexEntryC, inputStoreIndexOutTupleListC,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexOutEntryAB, outputStoreIndexOutEntryC,
indexerAB, indexerC);
this.mappingAB = mappingAB;
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected IndexProperties createIndexPropertiesLeft(BiTuple<A, B> leftTuple) {
return mappingAB.apply(leftTuple.factA, leftTuple.factB);
}
@Override
protected TriTuple<A, B, C> createOutTuple(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, rightTuple.factA, outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(TriTuple<A, B, C> outTuple, BiTuple<A, B> leftTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
}
@Override
protected void setOutTupleRightFact(TriTuple<A, B, C> outTuple, UniTuple<C> rightTuple) {
outTuple.factC = rightTuple.factA;
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, 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/MapTriToBiNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
final class MapTriToBiNode<A, B, C, NewA, NewB> extends AbstractMapNode<TriTuple<A, B, C>, BiTuple<NewA, NewB>> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
MapTriToBiNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunctionA, TriFunction<A, B, C, 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(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new BiTuple<>(
mappingFunctionA.apply(factA, factB, factC),
mappingFunctionB.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, BiTuple<NewA, NewB> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunctionA.apply(factA, factB, factC);
NewB newB = mappingFunctionB.apply(factA, factB, factC);
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/tri/MapTriToQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
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.TriFunction;
final class MapTriToQuadNode<A, B, C, NewA, NewB, NewC, NewD>
extends AbstractMapNode<TriTuple<A, B, C>, QuadTuple<NewA, NewB, NewC, NewD>> {
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;
MapTriToQuadNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB, TriFunction<A, B, C, NewC> mappingFunctionC,
TriFunction<A, B, C, 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(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new QuadTuple<>(
mappingFunctionA.apply(factA, factB, factC),
mappingFunctionB.apply(factA, factB, factC),
mappingFunctionC.apply(factA, factB, factC),
mappingFunctionD.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, QuadTuple<NewA, NewB, NewC, NewD> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunctionA.apply(factA, factB, factC);
NewB newB = mappingFunctionB.apply(factA, factB, factC);
NewC newC = mappingFunctionC.apply(factA, factB, factC);
NewD newD = mappingFunctionD.apply(factA, factB, factC);
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/tri/MapTriToTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
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.TriFunction;
final class MapTriToTriNode<A, B, C, NewA, NewB, NewC>
extends AbstractMapNode<TriTuple<A, B, C>, TriTuple<NewA, NewB, NewC>> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private final TriFunction<A, B, C, NewC> mappingFunctionC;
MapTriToTriNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunctionA, TriFunction<A, B, C, NewB> mappingFunctionB,
TriFunction<A, B, C, 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(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new TriTuple<>(
mappingFunctionA.apply(factA, factB, factC),
mappingFunctionB.apply(factA, factB, factC),
mappingFunctionC.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, TriTuple<NewA, NewB, NewC> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunctionA.apply(factA, factB, factC);
NewB newB = mappingFunctionB.apply(factA, factB, factC);
NewC newC = mappingFunctionC.apply(factA, factB, factC);
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/tri/MapTriToUniNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
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.TriFunction;
final class MapTriToUniNode<A, B, C, NewA> extends AbstractMapNode<TriTuple<A, B, C>, UniTuple<NewA>> {
private final TriFunction<A, B, C, NewA> mappingFunction;
MapTriToUniNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunction,
TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
protected UniTuple<NewA> map(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new UniTuple<>(
mappingFunction.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, UniTuple<NewA> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunction.apply(factA, factB, factC);
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/tri/TriScorer.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractScorer;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TriTuple;
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;
final class TriScorer<A, B, C> extends AbstractScorer<TriTuple<A, B, C>> {
private final QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> scoreImpacter;
public TriScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter,
QuadFunction<WeightedScoreImpacter<?, ?>, A, B, C, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(weightedScoreImpacter, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(TriTuple<A, B, C> tuple) {
try {
return scoreImpacter.apply(weightedScoreImpacter, tuple.factA, tuple.factB, tuple.factC);
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/UnindexedIfExistsTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedIfExistsNode;
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 UnindexedIfExistsTriNode<A, B, C, D> extends AbstractUnindexedIfExistsNode<TriTuple<A, B, C>, D> {
private final QuadPredicate<A, B, C, D> filtering;
public UnindexedIfExistsTriNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightEntry,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle) {
this(shouldExist,
inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public UnindexedIfExistsTriNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList, int inputStoreIndexRightEntry,
int inputStoreIndexRightTrackerList,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
QuadPredicate<A, B, C, D> filtering) {
super(shouldExist,
inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList, inputStoreIndexRightEntry,
inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@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/UnindexedJoinTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
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.TriPredicate;
final class UnindexedJoinTriNode<A, B, C>
extends AbstractUnindexedJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>> {
private final TriPredicate<A, B, C> filtering;
private final int outputStoreSize;
public UnindexedJoinTriNode(
int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, TriPredicate<A, B, C> 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 TriTuple<A, B, C> createOutTuple(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, rightTuple.factA, outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(TriTuple<A, B, C> outTuple, BiTuple<A, B> leftTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
}
@Override
protected void setOutTupleRightFact(TriTuple<A, B, C> outTuple, UniTuple<C> rightTuple) {
outTuple.factC = rightTuple.factA;
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, 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/uni/AbstractForEachUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.IdentityHashMap;
import java.util.Map;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractNode;
import ai.timefold.solver.constraint.streams.bavet.common.Propagator;
import ai.timefold.solver.constraint.streams.bavet.common.StaticPropagationQueue;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleState;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
/**
* Filtering nodes are expensive.
* Considering that most streams start with a nullity check on genuine planning variables,
* it makes sense to create a specialized version of the node for this case ({@link ForEachExcludingUnassignedUniNode}),
* as opposed to forcing an extra filter node on the generic case ({@link ForEachIncludingUnassignedUniNode}).
*
* @param <A>
*/
public abstract sealed class AbstractForEachUniNode<A>
extends AbstractNode
permits ForEachExcludingUnassignedUniNode, ForEachIncludingUnassignedUniNode {
private final Class<A> forEachClass;
private final int outputStoreSize;
private final StaticPropagationQueue<UniTuple<A>> propagationQueue;
protected final Map<A, UniTuple<A>> tupleMap = new IdentityHashMap<>(1000);
public AbstractForEachUniNode(Class<A> forEachClass, TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
int outputStoreSize) {
this.forEachClass = forEachClass;
this.outputStoreSize = outputStoreSize;
this.propagationQueue = new StaticPropagationQueue<>(nextNodesTupleLifecycle);
}
public void insert(A a) {
UniTuple<A> tuple = new UniTuple<>(a, outputStoreSize);
UniTuple<A> old = tupleMap.put(a, tuple);
if (old != null) {
throw new IllegalStateException("The fact (" + a + ") was already inserted, so it cannot insert again.");
}
propagationQueue.insert(tuple);
}
public abstract void update(A a);
protected final void innerUpdate(A a, UniTuple<A> tuple) {
TupleState state = tuple.state;
if (state.isDirty()) {
if (state == TupleState.DYING || state == TupleState.ABORTING) {
throw new IllegalStateException("The fact (" + a + ") was retracted, so it cannot update.");
}
// CREATING or UPDATING is ignored; it's already in the queue.
} else {
propagationQueue.update(tuple);
}
}
public void retract(A a) {
UniTuple<A> tuple = tupleMap.remove(a);
if (tuple == null) {
throw new IllegalStateException("The fact (" + a + ") was never inserted, so it cannot retract.");
}
TupleState state = tuple.state;
if (state.isDirty()) {
if (state == TupleState.DYING || state == TupleState.ABORTING) {
throw new IllegalStateException("The fact (" + a + ") was already retracted, so it cannot retract.");
}
propagationQueue.retract(tuple, state == TupleState.CREATING ? TupleState.ABORTING : TupleState.DYING);
} else {
propagationQueue.retract(tuple, TupleState.DYING);
}
}
@Override
public Propagator getPropagator() {
return propagationQueue;
}
public final Class<A> getForEachClass() {
return forEachClass;
}
@Override
public final String toString() {
return super.toString() + "(" + forEachClass.getSimpleName() + ")";
}
}
|
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/uni/AbstractGroupUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.BiFunction;
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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
abstract class AbstractGroupUniNode<OldA, OutTuple_ extends AbstractTuple, GroupKey_, ResultContainer_, Result_>
extends AbstractGroupNode<UniTuple<OldA>, OutTuple_, GroupKey_, ResultContainer_, Result_> {
private final BiFunction<ResultContainer_, OldA, Runnable> accumulator;
protected AbstractGroupUniNode(int groupStoreIndex, int undoStoreIndex,
Function<UniTuple<OldA>, GroupKey_> groupKeyFunction,
UniConstraintCollector<OldA, 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 AbstractGroupUniNode(int groupStoreIndex,
Function<UniTuple<OldA>, GroupKey_> groupKeyFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
super(groupStoreIndex,
groupKeyFunction, nextNodesTupleLifecycle, environmentMode);
accumulator = null;
}
@Override
protected final Runnable accumulate(ResultContainer_ resultContainer, UniTuple<OldA> tuple) {
return accumulator.apply(resultContainer, tuple.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/uni/BavetAbstractUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetAbstractBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetConcatBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetJoinBiConstraintStream;
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.tri.BavetAbstractTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetConcatTriConstraintStream;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.constraint.streams.common.bi.BiJoinerComber;
import ai.timefold.solver.constraint.streams.common.uni.InnerUniConstraintStream;
import ai.timefold.solver.constraint.streams.common.uni.UniConstraintBuilderImpl;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
public abstract class BavetAbstractUniConstraintStream<Solution_, A> extends BavetAbstractConstraintStream<Solution_>
implements InnerUniConstraintStream<A> {
protected BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent);
}
protected BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
// ************************************************************************
// Filter
// ************************************************************************
@Override
public BavetAbstractUniConstraintStream<Solution_, A> filter(Predicate<A> predicate) {
return shareAndAddChild(new BavetFilterUniConstraintStream<>(constraintFactory, this, predicate));
}
// ************************************************************************
// Join
// ************************************************************************
@Override
@SafeVarargs
public final <B> BiConstraintStream<A, B> join(UniConstraintStream<B> otherStream,
BiJoiner<A, B>... joiners) {
BiJoinerComber<A, B> joinerComber = BiJoinerComber.comb(joiners);
return join(otherStream, joinerComber);
}
@Override
public final <B> BiConstraintStream<A, B> join(UniConstraintStream<B> otherStream, BiJoinerComber<A, B> joinerComber) {
var other = (BavetAbstractUniConstraintStream<Solution_, B>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var joinStream = new BavetJoinBiConstraintStream<>(constraintFactory, leftBridge, rightBridge,
joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering());
return constraintFactory.share(joinStream, joinStream_ -> {
// Connect the bridges upstream, as it is an actual new join.
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final <B> UniConstraintStream<A> ifExists(Class<B> otherClass, BiJoiner<A, B>... 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 <B> UniConstraintStream<A> ifExistsIncludingUnassigned(Class<B> otherClass, BiJoiner<A, B>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <B> UniConstraintStream<A> ifExists(UniConstraintStream<B> otherStream, BiJoiner<A, B>... joiners) {
return ifExistsOrNot(true, otherStream, joiners);
}
@SafeVarargs
@Override
public final <B> UniConstraintStream<A> ifNotExists(Class<B> otherClass, BiJoiner<A, B>... 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 <B> UniConstraintStream<A> ifNotExistsIncludingUnassigned(Class<B> otherClass, BiJoiner<A, B>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifNotExists(constraintFactory.fromUnfiltered(otherClass), joiners);
}
}
@SafeVarargs
public final <B> UniConstraintStream<A> ifNotExists(UniConstraintStream<B> otherStream, BiJoiner<A, B>... joiners) {
return ifExistsOrNot(false, otherStream, joiners);
}
private <B> UniConstraintStream<A> ifExistsOrNot(boolean shouldExist, UniConstraintStream<B> otherStream,
BiJoiner<A, B>[] joiners) {
var other = (BavetAbstractUniConstraintStream<Solution_, B>) otherStream;
var joinerComber = BiJoinerComber.comb(joiners);
var parentBridgeB = other.shareAndAddChild(new BavetForeBridgeUniConstraintStream<>(constraintFactory, other));
return constraintFactory.share(
new BavetIfExistsUniConstraintStream<>(constraintFactory, this, parentBridgeB,
shouldExist, joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering()),
childStreamList::add);
}
// ************************************************************************
// Group by
// ************************************************************************
@Override
public <ResultContainer_, Result_> UniConstraintStream<Result_> groupBy(
UniConstraintCollector<A, ResultContainer_, Result_> collector) {
GroupNodeConstructor<UniTuple<Result_>> nodeConstructor =
zeroKeysGroupBy(collector, Group0Mapping1CollectorUniNode::new);
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
var stream = shareAndAddChild(new BavetUniGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_> BiConstraintStream<ResultA_, ResultB_> groupBy(
UniConstraintCollector<A, ResultContainerA_, ResultA_> collectorA,
UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB) {
GroupNodeConstructor<BiTuple<ResultA_, ResultB_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, Group0Mapping2CollectorUniNode::new);
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
var stream = shareAndAddChild(new BavetBiGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(UniConstraintCollector<A, ResultContainerA_, ResultA_> collectorA,
UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, Group0Mapping3CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
var stream = shareAndAddChild(new BavetTriGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(UniConstraintCollector<A, ResultContainerA_, ResultA_> collectorA,
UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC,
UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<ResultA_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
zeroKeysGroupBy(collectorA, collectorB, collectorC, collectorD, Group0Mapping4CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
var stream = shareAndAddChild(new BavetQuadGroupUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(Function<A, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, Group1Mapping0CollectorUniNode::new);
return buildUniGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<GroupKey_, ResultB_, ResultC_> groupBy(Function<A, GroupKey_> groupKeyMapping,
UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<GroupKey_, ResultB_, ResultC_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, Group1Mapping2CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(Function<A, GroupKey_> groupKeyMapping,
UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC,
UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKey_, ResultB_, ResultC_, ResultD_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collectorB, collectorC, collectorD, Group1Mapping3CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainer_, Result_> BiConstraintStream<GroupKey_, Result_> groupBy(
Function<A, GroupKey_> groupKeyMapping,
UniConstraintCollector<A, ResultContainer_, Result_> collector) {
GroupNodeConstructor<BiTuple<GroupKey_, Result_>> nodeConstructor =
oneKeyGroupBy(groupKeyMapping, collector, Group1Mapping1CollectorUniNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
Function<A, GroupKeyA_> groupKeyAMapping, Function<A, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, Group2Mapping0CollectorUniNode::new);
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainer_, Result_> TriConstraintStream<GroupKeyA_, GroupKeyB_, Result_> groupBy(
Function<A, GroupKeyA_> groupKeyAMapping, Function<A, GroupKeyB_> groupKeyBMapping,
UniConstraintCollector<A, ResultContainer_, Result_> collector) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, Result_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collector, Group2Mapping1CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
Function<A, GroupKeyA_> groupKeyAMapping, Function<A, GroupKeyB_> groupKeyBMapping,
UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC,
UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_>> nodeConstructor =
twoKeysGroupBy(groupKeyAMapping, groupKeyBMapping, collectorC, collectorD, Group2Mapping2CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_> TriConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_> groupBy(
Function<A, GroupKeyA_> groupKeyAMapping, Function<A, GroupKeyB_> groupKeyBMapping,
Function<A, GroupKeyC_> groupKeyCMapping) {
GroupNodeConstructor<TriTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, Group3Mapping0CollectorUniNode::new);
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>
groupBy(Function<A, GroupKeyA_> groupKeyAMapping, Function<A, GroupKeyB_> groupKeyBMapping,
Function<A, GroupKeyC_> groupKeyCMapping,
UniConstraintCollector<A, ResultContainerD_, ResultD_> collectorD) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, ResultD_>> nodeConstructor =
threeKeysGroupBy(groupKeyAMapping, groupKeyBMapping,
groupKeyCMapping, collectorD, Group3Mapping1CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_> QuadConstraintStream<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>
groupBy(Function<A, GroupKeyA_> groupKeyAMapping, Function<A, GroupKeyB_> groupKeyBMapping,
Function<A, GroupKeyC_> groupKeyCMapping, Function<A, GroupKeyD_> groupKeyDMapping) {
GroupNodeConstructor<QuadTuple<GroupKeyA_, GroupKeyB_, GroupKeyC_, GroupKeyD_>> nodeConstructor =
fourKeysGroupBy(groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping,
Group4Mapping0CollectorUniNode::new);
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public UniConstraintStream<A> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(ConstantLambdaUtils.identity());
}
}
@Override
public UniConstraintStream<A> concat(UniConstraintStream<A> otherStream) {
var other = (BavetAbstractUniConstraintStream<Solution_, A>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatUniConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public <B> BiConstraintStream<A, B> concat(BiConstraintStream<A, B> otherStream) {
var other = (BavetAbstractBiConstraintStream<Solution_, A, B>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(constraintFactory, this);
var rightBridge = new BavetForeBridgeBiConstraintStream<>(constraintFactory, other);
var concatStream = new BavetConcatBiConstraintStream<>(constraintFactory, leftBridge, rightBridge);
return constraintFactory.share(concatStream, concatStream_ -> {
// Connect the bridges upstream
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
@Override
public <B, C> TriConstraintStream<A, B, C> concat(TriConstraintStream<A, B, C> otherStream) {
var other = (BavetAbstractTriConstraintStream<Solution_, A, B, C>) otherStream;
var leftBridge = new BavetForeBridgeUniConstraintStream<>(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 <B, C, 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 BavetForeBridgeUniConstraintStream<>(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(Function<A, ResultA_> mapping) {
var stream = shareAndAddChild(new BavetUniMapUniConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_> BiConstraintStream<ResultA_, ResultB_> map(Function<A, ResultA_> mappingA,
Function<A, ResultB_> mappingB) {
var stream =
shareAndAddChild(new BavetBiMapUniConstraintStream<>(constraintFactory, this, mappingA, mappingB, false));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_> TriConstraintStream<ResultA_, ResultB_, ResultC_> map(Function<A, ResultA_> mappingA,
Function<A, ResultB_> mappingB, Function<A, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapUniConstraintStream<>(constraintFactory, this, mappingA, mappingB, mappingC, false));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_, ResultB_, ResultC_, ResultD_> QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_> map(
Function<A, ResultA_> mappingA, Function<A, ResultB_> mappingB, Function<A, ResultC_> mappingC,
Function<A, ResultD_> mappingD) {
var stream = shareAndAddChild(new BavetQuadMapUniConstraintStream<>(constraintFactory, this, mappingA, mappingB,
mappingC, mappingD, false));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultA_> UniConstraintStream<ResultA_> flattenLast(Function<A, Iterable<ResultA_>> mapping) {
var stream = shareAndAddChild(new BavetFlattenLastUniConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(new BavetAftBridgeUniConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Other operations
// ************************************************************************
@Override
public <ResultB_> BiConstraintStream<A, ResultB_> expand(Function<A, ResultB_> mapping) {
var stream =
shareAndAddChild(
new BavetBiMapUniConstraintStream<>(constraintFactory, this,
ConstantLambdaUtils.identity(), mapping, true));
return constraintFactory.share(new BavetAftBridgeBiConstraintStream<>(constraintFactory, stream), stream::setAftBridge);
}
@Override
public <ResultB_, ResultC_> TriConstraintStream<A, ResultB_, ResultC_> expand(Function<A, ResultB_> mappingB,
Function<A, ResultC_> mappingC) {
var stream = shareAndAddChild(
new BavetTriMapUniConstraintStream<>(constraintFactory, this, ConstantLambdaUtils.identity(),
mappingB, mappingC,
true));
return constraintFactory.share(new BavetAftBridgeTriConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
@Override
public <ResultB_, ResultC_, ResultD_> QuadConstraintStream<A, ResultB_, ResultC_, ResultD_>
expand(Function<A, ResultB_> mappingB, Function<A, ResultC_> mappingC, Function<A, ResultD_> mappingD) {
var stream = shareAndAddChild(
new BavetQuadMapUniConstraintStream<>(constraintFactory, this, ConstantLambdaUtils.identity(),
mappingB,
mappingC, mappingD, true));
return constraintFactory.share(new BavetAftBridgeQuadConstraintStream<>(constraintFactory, stream),
stream::setAftBridge);
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToIntFunction<A> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringUniConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
private <Score_ extends Score<Score_>> UniConstraintBuilderImpl<A, Score_> newTerminator(
BavetScoringConstraintStream<Solution_> stream, Score_ constraintWeight, ScoreImpactType impactType) {
return new UniConstraintBuilderImpl<>(
(constraintPackage, constraintName, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping) -> buildConstraint(
constraintPackage, constraintName, constraintWeight_, impactType_, justificationMapping,
indictedObjectsMapping, stream),
impactType, constraintWeight);
}
@Override
public <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToLongFunction<A> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringUniConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
public <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType) {
var stream = shareAndAddChild(new BavetScoringUniConstraintStream<>(constraintFactory, this, matchWeigher));
return newTerminator(stream, constraintWeight, scoreImpactType);
}
@Override
protected final BiFunction<A, Score<?>, DefaultConstraintJustification> getDefaultJustificationMapping() {
return InnerUniConstraintStream.createDefaultJustificationMapping();
}
@Override
protected final Function<A, Collection<?>> getDefaultIndictedObjectsMapping() {
return InnerUniConstraintStream.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/uni/BavetBiGroupUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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 BavetBiGroupUniConstraintStream<Solution_, A, NewA, NewB>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(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 = (BavetBiGroupUniConstraintStream<?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "BiGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetBiMapUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.BavetAftBridgeBiConstraintStream;
import ai.timefold.solver.core.api.score.Score;
final class BavetBiMapUniConstraintStream<Solution_, A, NewA, NewB>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final boolean guaranteesDistinct;
private BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream;
public BavetBiMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunctionA,
Function<A, NewB> mappingFunctionB, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeBiConstraintStream<Solution_, NewA, NewB> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapUniToBiNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetBiMapUniConstraintStream<?, ?, ?, ?> that = (BavetBiMapUniConstraintStream<?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) &&
guaranteesDistinct == that.guaranteesDistinct && Objects.equals(mappingFunctionA,
that.mappingFunctionA)
&& Objects.equals(mappingFunctionB, that.mappingFunctionB);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "BiMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetConcatUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.BavetConcatConstraintStream;
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.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.api.score.Score;
public final class BavetConcatUniConstraintStream<Solution_, A> extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetConcatConstraintStream<Solution_> {
private final BavetForeBridgeUniConstraintStream<Solution_, A> leftParent;
private final BavetForeBridgeUniConstraintStream<Solution_, A> rightParent;
public BavetConcatUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetForeBridgeUniConstraintStream<Solution_, A> leftParent,
BavetForeBridgeUniConstraintStream<Solution_, A> rightParent) {
super(constraintFactory, leftParent.getRetrievalSemantics());
this.leftParent = leftParent;
this.rightParent = rightParent;
}
@Override
public boolean guaranteesDistinct() {
return false; // The two parents could have the same source; guarantee impossible.
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
leftParent.collectActiveConstraintStreams(constraintStreamSet);
rightParent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<UniTuple<A>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int leftCloneStoreIndex = buildHelper.reserveTupleStoreIndex(leftParent.getTupleSource());
int rightCloneStoreIndex = buildHelper.reserveTupleStoreIndex(rightParent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = new ConcatUniUniNode<>(downstream,
leftCloneStoreIndex,
rightCloneStoreIndex,
outputStoreSize);
buildHelper.addNode(node, this, leftParent, rightParent);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
BavetConcatUniConstraintStream<?, ?> other = (BavetConcatUniConstraintStream<?, ?>) 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;
}
}
|
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/uni/BavetFilterUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.function.Predicate;
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.UniTuple;
import ai.timefold.solver.core.api.score.Score;
final class BavetFilterUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Predicate<A> predicate;
public BavetFilterUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Predicate<A> predicate) {
super(constraintFactory, parent);
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
buildHelper.<UniTuple<A>> putInsertUpdateRetract(this, childStreamList,
tupleLifecycle -> new ConditionalUniTupleLifecycle<>(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 BavetFilterUniConstraintStream other) {
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetFlattenLastUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.api.score.Score;
final class BavetFlattenLastUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, Iterable<NewA>> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> flattenLastStream;
public BavetFlattenLastUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
Function<A, Iterable<NewA>> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
var node = new FlattenLastUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetFlattenLastUniConstraintStream<?, ?, ?> that = (BavetFlattenLastUniConstraintStream<?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "FlattenLast()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetForEachUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.Set;
import java.util.function.Predicate;
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.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.core.api.score.Score;
public final class BavetForEachUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements TupleSource {
private final Class<A> forEachClass;
private final Predicate<A> filter;
public BavetForEachUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory, Class<A> forEachClass,
Predicate<A> filter, RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
this.forEachClass = forEachClass;
if (forEachClass == null) {
throw new IllegalArgumentException("The forEachClass (null) cannot be null.");
}
this.filter = filter;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<UniTuple<A>> tupleLifecycle = buildHelper.getAggregatedTupleLifecycle(childStreamList);
int outputStoreSize = buildHelper.extractTupleStoreSize(this);
var node = filter == null ? new ForEachIncludingUnassignedUniNode<>(forEachClass, tupleLifecycle, outputStoreSize)
: new ForEachExcludingUnassignedUniNode<>(forEachClass, filter, tupleLifecycle, outputStoreSize);
buildHelper.addNode(node, this, null);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object other) {
if (this == other) {
return true;
}
if (other == null || getClass() != other.getClass()) {
return false;
}
BavetForEachUniConstraintStream<?, ?> that = (BavetForEachUniConstraintStream<?, ?>) other;
return Objects.equals(forEachClass, that.forEachClass) && Objects.equals(filter, that.filter);
}
@Override
public int hashCode() {
return Objects.hash(forEachClass, filter);
}
@Override
public String toString() {
if (filter != null) {
return "ForEach(" + forEachClass.getSimpleName() + ") with filter and " + childStreamList.size() + " children";
}
return "ForEach(" + forEachClass.getSimpleName() + ") with " + childStreamList.size() + " children";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetIfExistsUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.Set;
import java.util.function.BiPredicate;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.constraint.streams.common.bi.DefaultBiJoiner;
import ai.timefold.solver.core.api.score.Score;
final class BavetIfExistsUniConstraintStream<Solution_, A, B>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetIfExistsConstraintStream<Solution_> {
private final BavetAbstractUniConstraintStream<Solution_, A> parentA;
private final BavetForeBridgeUniConstraintStream<Solution_, B> parentBridgeB;
private final boolean shouldExist;
private final DefaultBiJoiner<A, B> joiner;
private final BiPredicate<A, B> filtering;
public BavetIfExistsUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parentA,
BavetForeBridgeUniConstraintStream<Solution_, B> parentBridgeB,
boolean shouldExist,
DefaultBiJoiner<A, B> joiner, BiPredicate<A, B> filtering) {
super(constraintFactory, parentA.getRetrievalSemantics());
this.parentA = parentA;
this.parentBridgeB = parentBridgeB;
this.shouldExist = shouldExist;
this.joiner = joiner;
this.filtering = filtering;
}
@Override
public boolean guaranteesDistinct() {
return parentA.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parentA.collectActiveConstraintStreams(constraintStreamSet);
parentBridgeB.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parentA.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
TupleLifecycle<UniTuple<A>> downstream = buildHelper.getAggregatedTupleLifecycle(childStreamList);
IndexerFactory<B> indexerFactory = new IndexerFactory<>(joiner);
var node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsUniNode<>(shouldExist,
indexerFactory.buildUniLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false))
: new IndexedIfExistsUniNode<>(shouldExist,
indexerFactory.buildUniLeftMapping(), indexerFactory.buildRightMapping(),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
downstream, indexerFactory.buildIndexer(true), indexerFactory.buildIndexer(false),
filtering))
: (filtering == null ? new UnindexedIfExistsUniNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()), downstream)
: new UnindexedIfExistsUniNode<>(shouldExist,
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentA.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
buildHelper.reserveTupleStoreIndex(parentBridgeB.getTupleSource()),
downstream, filtering));
buildHelper.addNode(node, this, this, parentBridgeB);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetIfExistsUniConstraintStream<?, ?, ?> that = (BavetIfExistsUniConstraintStream<?, ?, ?>) object;
/*
* Bridge streams do not implement equality because their equals() would have to point back to this stream,
* resulting in StackOverflowError.
* Therefore we need to check bridge parents to see where this ifExists node comes from.
*/
return shouldExist == that.shouldExist && Objects.equals(parentA,
that.parentA) && Objects.equals(
parentBridgeB.getParent(), that.parentBridgeB.getParent())
&& Objects.equals(joiner,
that.joiner)
&& Objects.equals(
filtering, that.filtering);
}
@Override
public int hashCode() {
return Objects.hash(parentA, parentBridgeB.getParent(), shouldExist, joiner, filtering);
}
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public BavetAbstractConstraintStream<Solution_> getLeftParent() {
return parentA;
}
@Override
public BavetAbstractConstraintStream<Solution_> getRightParent() {
return parentBridgeB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetQuadGroupUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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 BavetQuadGroupUniConstraintStream<Solution_, A, NewA, NewB, NewC, NewD>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(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 = (BavetQuadGroupUniConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "QuadGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetQuadMapUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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 BavetQuadMapUniConstraintStream<Solution_, A, NewA, NewB, NewC, NewD>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
private final Function<A, NewD> mappingFunctionD;
private final boolean guaranteesDistinct;
private BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream;
public BavetQuadMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunctionA,
Function<A, NewB> mappingFunctionB, Function<A, NewC> mappingFunctionC, Function<A, NewD> mappingFunctionD,
boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.mappingFunctionD = mappingFunctionD;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node =
new MapUniToQuadNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetQuadMapUniConstraintStream<?, ?, ?, ?, ?, ?> that = (BavetQuadMapUniConstraintStream<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC,
that.mappingFunctionC)
&& Objects.equals(mappingFunctionD, that.mappingFunctionD);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, mappingFunctionD, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "QuadMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetScoringUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.math.BigDecimal;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import ai.timefold.solver.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.score.Score;
final class BavetScoringUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetScoringConstraintStream<Solution_> {
private final ToIntFunction<A> intMatchWeigher;
private final ToLongFunction<A> longMatchWeigher;
private final Function<A, BigDecimal> bigDecimalMatchWeigher;
private BavetConstraint<Solution_> constraint;
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, ToIntFunction<A> intMatchWeigher) {
this(constraintFactory, parent, intMatchWeigher, null, null);
if (intMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, ToLongFunction<A> longMatchWeigher) {
this(constraintFactory, parent, null, longMatchWeigher, null);
if (longMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
public BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, BigDecimal> bigDecimalMatchWeigher) {
this(constraintFactory, parent, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, ToIntFunction<A> intMatchWeigher,
ToLongFunction<A> longMatchWeigher, Function<A, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent);
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
var constraintMatchEnabled = buildHelper.getScoreInliner().isConstraintMatchEnabled();
var scoreImpacter = constraintMatchEnabled ? buildScoreImpacterWithConstraintMatch() : buildScoreImpacter();
var weightedScoreImpacter = buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint);
var scorer = new UniScorer<>(weightedScoreImpacter, scoreImpacter,
buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
private BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> buildScoreImpacter() {
if (intMatchWeigher != null) {
return (impacter, a) -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
return impacter.impactScore(matchWeight, null);
};
} else if (longMatchWeigher != null) {
return (impacter, a) -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
return impacter.impactScore(matchWeight, null);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
return impacter.impactScore(matchWeight, null);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> buildScoreImpacterWithConstraintMatch() {
if (intMatchWeigher != null) {
return (impacter, a) -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
return impactWithConstraintMatch(impacter, matchWeight, a);
};
} else if (longMatchWeigher != null) {
return (impacter, a) -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
return impactWithConstraintMatch(impacter, matchWeight, a);
};
} else if (bigDecimalMatchWeigher != null) {
return (impacter, a) -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
return impactWithConstraintMatch(impacter, matchWeight, a);
};
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
}
private static <A, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, int matchWeight, A a) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, long matchWeight, A a) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
private static <A, Score_ extends Score<Score_>> UndoScoreImpacter
impactWithConstraintMatch(WeightedScoreImpacter<Score_, ?> impacter, BigDecimal matchWeight, A a) {
var constraint = impacter.getContext().getConstraint();
var constraintMatchSupplier = ConstraintMatchSupplier.<A, Score_> of(constraint.getJustificationMapping(),
constraint.getIndictedObjectsMapping(), a);
return impacter.impactScore(matchWeight, constraintMatchSupplier);
}
// ************************************************************************
// 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/uni/BavetTriGroupUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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 BavetTriGroupUniConstraintStream<Solution_, A, NewA, NewB, NewC>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(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 = (BavetTriGroupUniConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "TriGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetTriMapUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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 BavetTriMapUniConstraintStream<Solution_, A, NewA, NewB, NewC>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
private final boolean guaranteesDistinct;
private BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream;
public BavetTriMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunctionA,
Function<A, NewB> mappingFunctionB, Function<A, NewC> mappingFunctionC, boolean isExpand) {
super(constraintFactory, parent);
this.mappingFunctionA = mappingFunctionA;
this.mappingFunctionB = mappingFunctionB;
this.mappingFunctionC = mappingFunctionC;
this.guaranteesDistinct = isExpand && parent.guaranteesDistinct();
}
@Override
public boolean guaranteesDistinct() {
return guaranteesDistinct;
}
public void setAftBridge(BavetAftBridgeTriConstraintStream<Solution_, NewA, NewB, NewC> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapUniToTriNode<>(inputStoreIndex, mappingFunctionA, mappingFunctionB, mappingFunctionC,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetTriMapUniConstraintStream<?, ?, ?, ?, ?> that = (BavetTriMapUniConstraintStream<?, ?, ?, ?, ?>) object;
return Objects.equals(parent, that.parent) && guaranteesDistinct == that.guaranteesDistinct && Objects.equals(
mappingFunctionA,
that.mappingFunctionA) && Objects.equals(mappingFunctionB,
that.mappingFunctionB)
&& Objects.equals(mappingFunctionC, that.mappingFunctionC);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunctionA, mappingFunctionB, mappingFunctionC, guaranteesDistinct);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "TriMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetUniGroupUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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 BavetUniGroupUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent);
this.nodeConstructor = nodeConstructor;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public <Score_ extends Score<Score_>> void buildNode(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 = (BavetUniGroupUniConstraintStream<?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(nodeConstructor, that.nodeConstructor);
}
@Override
public int hashCode() {
return Objects.hash(parent, nodeConstructor);
}
@Override
public String toString() {
return "UniGroup()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/BavetUniMapUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.BavetAftBridgeUniConstraintStream;
import ai.timefold.solver.core.api.score.Score;
final class BavetUniMapUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final Function<A, NewA> mappingFunction;
private BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream;
public BavetUniMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunction) {
super(constraintFactory, parent);
this.mappingFunction = mappingFunction;
}
public void setAftBridge(BavetAftBridgeUniConstraintStream<Solution_, NewA> aftStream) {
this.aftStream = aftStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public boolean guaranteesDistinct() {
return false;
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
assertEmptyChildStreamList();
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(aftStream);
var node = new MapUniToUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(aftStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
BavetUniMapUniConstraintStream<?, ?, ?> that = (BavetUniMapUniConstraintStream<?, ?, ?>) object;
return Objects.equals(parent, that.parent) && Objects.equals(mappingFunction, that.mappingFunction);
}
@Override
public int hashCode() {
return Objects.hash(parent, mappingFunction);
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public String toString() {
return "UniMap()";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/ConcatUniUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConcatNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class ConcatUniUniNode<A>
extends AbstractConcatNode<UniTuple<A>, UniTuple<A>, UniTuple<A>> {
ConcatUniUniNode(TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList,
outputStoreSize);
}
@Override
protected UniTuple<A> getOutTupleFromLeft(UniTuple<A> leftTuple) {
return new UniTuple<>(leftTuple.factA, outputStoreSize);
}
@Override
protected UniTuple<A> getOutTupleFromRight(UniTuple<A> rightTuple) {
return new UniTuple<>(rightTuple.factA, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(UniTuple<A> leftTuple, UniTuple<A> outTuple) {
outTuple.factA = leftTuple.factA;
}
@Override
protected void updateOutTupleFromRight(UniTuple<A> rightTuple, UniTuple<A> 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/uni/ConditionalUniTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Predicate;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.AbstractConditionalTupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class ConditionalUniTupleLifecycle<A> extends AbstractConditionalTupleLifecycle<UniTuple<A>> {
private final Predicate<A> predicate;
public ConditionalUniTupleLifecycle(Predicate<A> predicate, TupleLifecycle<UniTuple<A>> tupleLifecycle) {
super(tupleLifecycle);
this.predicate = predicate;
}
@Override
protected boolean test(UniTuple<A> tuple) {
return predicate.test(tuple.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/uni/FlattenLastUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class FlattenLastUniNode<A, NewA> extends AbstractFlattenLastNode<UniTuple<A>, UniTuple<NewA>, A, NewA> {
private final int outputStoreSize;
FlattenLastUniNode(int flattenLastStoreIndex, Function<A, Iterable<NewA>> mappingFunction,
TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected UniTuple<NewA> createTuple(UniTuple<A> originalTuple, NewA item) {
return new UniTuple<>(item, outputStoreSize);
}
@Override
protected A getEffectiveFactIn(UniTuple<A> tuple) {
return tuple.factA;
}
@Override
protected NewA getEffectiveFactOut(UniTuple<NewA> outTuple) {
return outTuple.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/uni/ForEachExcludingUnassignedUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.function.Predicate;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
public final class ForEachExcludingUnassignedUniNode<A> extends AbstractForEachUniNode<A> {
private final Predicate<A> filter;
public ForEachExcludingUnassignedUniNode(Class<A> forEachClass, Predicate<A> filter,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize) {
super(forEachClass, nextNodesTupleLifecycle, outputStoreSize);
this.filter = Objects.requireNonNullElse(filter, a -> true);
}
@Override
public void insert(A a) {
if (!filter.test(a)) { // Skip inserting the tuple as it does not pass the filter.
return;
}
super.insert(a);
}
@Override
public void update(A a) {
UniTuple<A> tuple = tupleMap.get(a);
if (tuple == null) { // The tuple was never inserted because it did not pass the filter.
insert(a);
} else if (filter.test(a)) {
innerUpdate(a, tuple);
} else {
super.retract(a); // Call super.retract() to avoid testing the filter again.
}
}
@Override
public void retract(A a) {
if (!filter.test(a)) { // The tuple was never inserted because it did not pass the filter.
return;
}
super.retract(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/uni/ForEachIncludingUnassignedUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
public final class ForEachIncludingUnassignedUniNode<A> extends AbstractForEachUniNode<A> {
public ForEachIncludingUnassignedUniNode(Class<A> forEachClass, TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
int outputStoreSize) {
super(forEachClass, nextNodesTupleLifecycle, outputStoreSize);
}
@Override
public void update(A a) {
UniTuple<A> tuple = tupleMap.get(a);
if (tuple == null) {
throw new IllegalStateException("The fact (" + a + ") was never inserted, so it cannot update.");
}
innerUpdate(a, tuple);
}
}
|
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/uni/Group0Mapping1CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group0Mapping1CollectorUniNode<OldA, A, ResultContainer_>
extends AbstractGroupUniNode<OldA, UniTuple<A>, Void, ResultContainer_, A> {
private final int outputStoreSize;
public Group0Mapping1CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, 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/uni/Group0Mapping2CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group0Mapping2CollectorUniNode<OldA, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, 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, A, B, ResultContainerA_, ResultContainerB_>
UniConstraintCollector<OldA, Object, Pair<A, B>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB) {
return (UniConstraintCollector<OldA, 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/uni/Group0Mapping3CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group0Mapping3CollectorUniNode<OldA, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, 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, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
UniConstraintCollector<OldA, Object, Triple<A, B, C>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC) {
return (UniConstraintCollector<OldA, 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/uni/Group0Mapping4CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group0Mapping4CollectorUniNode<OldA, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB, collectorC, collectorD),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <OldA, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
UniConstraintCollector<OldA, Object, Quadruple<A, B, C, D>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD) {
return (UniConstraintCollector<OldA, 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/uni/Group1Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
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.config.solver.EnvironmentMode;
final class Group1Mapping0CollectorUniNode<OldA, A>
extends AbstractGroupUniNode<OldA, UniTuple<A>, A, Void, Void> {
private final int outputStoreSize;
public Group1Mapping0CollectorUniNode(Function<OldA, 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> A createGroupKey(Function<OldA, A> groupKeyMapping, UniTuple<OldA> tuple) {
return groupKeyMapping.apply(tuple.factA);
}
@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/uni/Group1Mapping1CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.bavet.uni.Group1Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping1CollectorUniNode<OldA, A, B, ResultContainer_>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorUniNode(Function<OldA, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, 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/uni/Group1Mapping2CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.bavet.uni.Group1Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group1Mapping2CollectorUniNode<OldA, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, A, Object, Pair<B, C>> {
private final int outputStoreSize;
public Group1Mapping2CollectorUniNode(Function<OldA, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorUniNode.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/uni/Group1Mapping3CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.bavet.uni.Group1Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group1Mapping3CollectorUniNode<OldA, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorUniNode(Function<OldA, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping3CollectorUniNode.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/uni/Group2Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.BiTuple;
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.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping0CollectorUniNode<OldA, A, B>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, 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> Pair<A, B> createGroupKey(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
UniTuple<OldA> tuple) {
OldA oldA = tuple.factA;
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
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/uni/Group2Mapping1CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.bavet.uni.Group2Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping1CollectorUniNode<OldA, A, B, C, ResultContainer_>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, Pair<A, B>, ResultContainer_, C> {
private final int outputStoreSize;
public Group2Mapping1CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, 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/uni/Group2Mapping2CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.bavet.uni.Group0Mapping2CollectorUniNode.mergeCollectors;
import static ai.timefold.solver.constraint.streams.bavet.uni.Group2Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping2CollectorUniNode<OldA, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, 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/uni/Group3Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
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.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping0CollectorUniNode<OldA, A, B, C>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
Function<OldA, 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> Triple<A, B, C> createGroupKey(Function<OldA, A> groupKeyMappingA,
Function<OldA, B> groupKeyMappingB, Function<OldA, C> groupKeyMappingC, UniTuple<OldA> tuple) {
OldA oldA = tuple.factA;
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
C c = groupKeyMappingC.apply(oldA);
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/uni/Group3Mapping1CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.bavet.uni.Group3Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
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.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping1CollectorUniNode<OldA, A, B, C, D, ResultContainer_>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Triple<A, B, C>, ResultContainer_, D> {
private final int outputStoreSize;
public Group3Mapping1CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
Function<OldA, C> groupKeyMappingC,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, 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/uni/Group4Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
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.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group4Mapping0CollectorUniNode<OldA, A, B, C, D>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
Function<OldA, C> groupKeyMappingC, Function<OldA, 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> Quadruple<A, B, C, D> createGroupKey(Function<OldA, A> groupKeyMappingA,
Function<OldA, B> groupKeyMappingB, Function<OldA, C> groupKeyMappingC, Function<OldA, D> groupKeyMappingD,
UniTuple<OldA> tuple) {
OldA oldA = tuple.factA;
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
C c = groupKeyMappingC.apply(oldA);
D d = groupKeyMappingD.apply(oldA);
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/uni/IndexedIfExistsUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.BiPredicate;
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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class IndexedIfExistsUniNode<A, B> extends AbstractIndexedIfExistsNode<UniTuple<A>, B> {
private final Function<A, IndexProperties> mappingA;
private final BiPredicate<A, B> filtering;
public IndexedIfExistsUniNode(boolean shouldExist,
Function<A, IndexProperties> mappingA, Function<B, IndexProperties> mappingB,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightProperties,
int inputStoreIndexRightEntry,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<UniTuple<A>>> indexerA, Indexer<UniTuple<B>> indexerB) {
this(shouldExist, mappingA, mappingB,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightProperties,
inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, indexerA, indexerB, null);
}
public IndexedIfExistsUniNode(boolean shouldExist,
Function<A, IndexProperties> mappingA, Function<B, IndexProperties> mappingB,
int inputStoreIndexLeftProperties, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightProperties, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
Indexer<ExistsCounter<UniTuple<A>>> indexerA, Indexer<UniTuple<B>> indexerB,
BiPredicate<A, B> filtering) {
super(shouldExist, mappingB,
inputStoreIndexLeftProperties, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightProperties, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, indexerA, indexerB, filtering != null);
this.mappingA = mappingA;
this.filtering = filtering;
}
@Override
protected IndexProperties createIndexProperties(UniTuple<A> leftTuple) {
return mappingA.apply(leftTuple.factA);
}
@Override
protected boolean testFiltering(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return filtering.test(leftTuple.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/uni/MapUniToBiNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class MapUniToBiNode<A, NewA, NewB> extends AbstractMapNode<UniTuple<A>, BiTuple<NewA, NewB>> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
MapUniToBiNode(int mapStoreIndex, Function<A, NewA> mappingFunctionA, Function<A, 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(UniTuple<A> tuple) {
A factA = tuple.factA;
return new BiTuple<>(
mappingFunctionA.apply(factA),
mappingFunctionB.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, BiTuple<NewA, NewB> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunctionA.apply(factA);
NewB newB = mappingFunctionB.apply(factA);
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/uni/MapUniToQuadNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
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;
final class MapUniToQuadNode<A, NewA, NewB, NewC, NewD>
extends AbstractMapNode<UniTuple<A>, QuadTuple<NewA, NewB, NewC, NewD>> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
private final Function<A, NewD> mappingFunctionD;
MapUniToQuadNode(int mapStoreIndex, Function<A, NewA> mappingFunctionA, Function<A, NewB> mappingFunctionB,
Function<A, NewC> mappingFunctionC, Function<A, 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(UniTuple<A> tuple) {
A factA = tuple.factA;
return new QuadTuple<>(
mappingFunctionA.apply(factA),
mappingFunctionB.apply(factA),
mappingFunctionC.apply(factA),
mappingFunctionD.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, QuadTuple<NewA, NewB, NewC, NewD> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunctionA.apply(factA);
NewB newB = mappingFunctionB.apply(factA);
NewC newC = mappingFunctionC.apply(factA);
NewD newD = mappingFunctionD.apply(factA);
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/uni/MapUniToTriNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
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;
final class MapUniToTriNode<A, NewA, NewB, NewC> extends AbstractMapNode<UniTuple<A>, TriTuple<NewA, NewB, NewC>> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
MapUniToTriNode(int mapStoreIndex, Function<A, NewA> mappingFunctionA, Function<A, NewB> mappingFunctionB,
Function<A, 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(UniTuple<A> tuple) {
A factA = tuple.factA;
return new TriTuple<>(
mappingFunctionA.apply(factA),
mappingFunctionB.apply(factA),
mappingFunctionC.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, TriTuple<NewA, NewB, NewC> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunctionA.apply(factA);
NewB newB = mappingFunctionB.apply(factA);
NewC newC = mappingFunctionC.apply(factA);
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/uni/MapUniToUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class MapUniToUniNode<A, NewA> extends AbstractMapNode<UniTuple<A>, UniTuple<NewA>> {
private final Function<A, NewA> mappingFunction;
MapUniToUniNode(int mapStoreIndex, Function<A, NewA> mappingFunction,
TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
protected UniTuple<NewA> map(UniTuple<A> tuple) {
A factA = tuple.factA;
return new UniTuple<>(
mappingFunction.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, UniTuple<NewA> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunction.apply(factA);
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/uni/UniScorer.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractScorer;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.constraint.streams.common.inliner.WeightedScoreImpacter;
final class UniScorer<A> extends AbstractScorer<UniTuple<A>> {
private final BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> scoreImpacter;
public UniScorer(WeightedScoreImpacter<?, ?> weightedScoreImpacter,
BiFunction<WeightedScoreImpacter<?, ?>, A, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(weightedScoreImpacter, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(UniTuple<A> tuple) {
try {
return scoreImpacter.apply(weightedScoreImpacter, tuple.factA);
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-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/uni/UnindexedIfExistsUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.BiPredicate;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedIfExistsNode;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.tuple.UniTuple;
final class UnindexedIfExistsUniNode<A, B> extends AbstractUnindexedIfExistsNode<UniTuple<A>, B> {
private final BiPredicate<A, B> filtering;
public UnindexedIfExistsUniNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightEntry,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle) {
this(shouldExist,
inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public UnindexedIfExistsUniNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList, int inputStoreIndexRightEntry,
int inputStoreIndexRightTrackerList,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
BiPredicate<A, B> filtering) {
super(shouldExist,
inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList, inputStoreIndexRightEntry,
inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return filtering.test(leftTuple.factA, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/AbstractConstraint.java | package ai.timefold.solver.constraint.streams.common;
import java.math.BigDecimal;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.Constraint;
public abstract class AbstractConstraint<Solution_, Constraint_ extends AbstractConstraint<Solution_, Constraint_, ConstraintFactory_>, ConstraintFactory_ extends InnerConstraintFactory<Solution_, Constraint_>>
implements Constraint {
private final ConstraintFactory_ constraintFactory;
private final ConstraintRef constraintRef;
private final Function<Solution_, Score<?>> constraintWeightExtractor;
private final ScoreImpactType scoreImpactType;
private final boolean isConstraintWeightConfigurable;
// Constraint is not generic in uni/bi/..., therefore these can not be typed.
private final Object justificationMapping;
private final Object indictedObjectsMapping;
protected AbstractConstraint(ConstraintFactory_ constraintFactory, ConstraintRef constraintRef,
Function<Solution_, Score<?>> constraintWeightExtractor, ScoreImpactType scoreImpactType,
boolean isConstraintWeightConfigurable, Object justificationMapping, Object indictedObjectsMapping) {
this.constraintFactory = constraintFactory;
this.constraintRef = constraintRef;
this.constraintWeightExtractor = constraintWeightExtractor;
this.scoreImpactType = scoreImpactType;
this.isConstraintWeightConfigurable = isConstraintWeightConfigurable;
this.justificationMapping = justificationMapping;
this.indictedObjectsMapping = indictedObjectsMapping;
}
public final <Score_ extends Score<Score_>> Score_ extractConstraintWeight(Solution_ workingSolution) {
if (isConstraintWeightConfigurable && workingSolution == null) {
/*
* In constraint verifier API, we allow for testing constraint providers without having a planning solution.
* However, constraint weights may be configurable and in that case the solution is required to read the
* weights from.
* For these cases, we set the constraint weight to the softest possible value, just to make sure that the
* constraint is not ignored.
* The actual value is not used in any way.
*/
return (Score_) constraintFactory.getSolutionDescriptor().getScoreDefinition().getOneSoftestScore();
}
var constraintWeight = (Score_) constraintWeightExtractor.apply(workingSolution);
constraintFactory.getSolutionDescriptor().validateConstraintWeight(constraintRef, constraintWeight);
return switch (scoreImpactType) {
case PENALTY -> constraintWeight.negate();
case REWARD, MIXED -> constraintWeight;
};
}
public final void assertCorrectImpact(int impact) {
if (impact >= 0) {
return;
}
if (scoreImpactType != ScoreImpactType.MIXED) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ constraintRef + "). " +
"Check constraint provider implementation.");
}
}
public final void assertCorrectImpact(long impact) {
if (impact >= 0L) {
return;
}
if (scoreImpactType != ScoreImpactType.MIXED) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ getConstraintRef() + "). " +
"Check constraint provider implementation.");
}
}
public final void assertCorrectImpact(BigDecimal impact) {
if (impact.signum() >= 0) {
return;
}
if (scoreImpactType != ScoreImpactType.MIXED) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ getConstraintRef() + "). " +
"Check constraint provider implementation.");
}
}
@Override
public final ConstraintFactory_ getConstraintFactory() {
return constraintFactory;
}
@Override
public ConstraintRef getConstraintRef() {
return constraintRef;
}
public final ScoreImpactType getScoreImpactType() {
return scoreImpactType;
}
public <JustificationMapping_> JustificationMapping_ getJustificationMapping() {
// It is the job of the code constructing the constraint to ensure that this cast is correct.
return (JustificationMapping_) justificationMapping;
}
public <IndictedObjectsMapping_> IndictedObjectsMapping_ getIndictedObjectsMapping() {
// It is the job of the code constructing the constraint to ensure that this cast is correct.
return (IndictedObjectsMapping_) indictedObjectsMapping;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/AbstractConstraintBuilder.java | package ai.timefold.solver.constraint.streams.common;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintBuilder;
public abstract class AbstractConstraintBuilder<Score_ extends Score<Score_>> implements ConstraintBuilder {
private final ConstraintConstructor constraintConstructor;
private final ScoreImpactType impactType;
private final Score_ constraintWeight;
protected AbstractConstraintBuilder(ConstraintConstructor constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
this.constraintConstructor = Objects.requireNonNull(constraintConstructor);
this.impactType = Objects.requireNonNull(impactType);
this.constraintWeight = constraintWeight;
}
protected abstract <JustificationMapping_> JustificationMapping_ getJustificationMapping();
protected abstract <IndictedObjectsMapping_> IndictedObjectsMapping_ getIndictedObjectsMapping();
@Override
public final Constraint asConstraint(String constraintName) {
return constraintConstructor.apply(null, constraintName, constraintWeight, impactType,
getJustificationMapping(), getIndictedObjectsMapping());
}
@Override
public final Constraint asConstraint(String constraintPackage, String constraintName) {
return constraintConstructor.apply(constraintPackage, constraintName, constraintWeight, impactType,
getJustificationMapping(), getIndictedObjectsMapping());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/AbstractConstraintStream.java | package ai.timefold.solver.constraint.streams.common;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.domain.constraintweight.ConstraintConfiguration;
import ai.timefold.solver.core.api.domain.constraintweight.ConstraintConfigurationProvider;
import ai.timefold.solver.core.api.domain.constraintweight.ConstraintWeight;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
import ai.timefold.solver.core.impl.domain.constraintweight.descriptor.ConstraintConfigurationDescriptor;
import ai.timefold.solver.core.impl.domain.constraintweight.descriptor.ConstraintWeightDescriptor;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
public abstract class AbstractConstraintStream<Solution_> implements ConstraintStream {
private final RetrievalSemantics retrievalSemantics;
protected AbstractConstraintStream(RetrievalSemantics retrievalSemantics) {
this.retrievalSemantics = Objects.requireNonNull(retrievalSemantics);
}
public RetrievalSemantics getRetrievalSemantics() {
return retrievalSemantics;
}
// ************************************************************************
// Penalize/reward
// ************************************************************************
protected Function<Solution_, Score<?>> buildConstraintWeightExtractor(ConstraintRef constraintRef) {
SolutionDescriptor<Solution_> solutionDescriptor = getConstraintFactory().getSolutionDescriptor();
ConstraintConfigurationDescriptor<Solution_> configurationDescriptor = solutionDescriptor
.getConstraintConfigurationDescriptor();
if (configurationDescriptor == null) {
throw new IllegalStateException("The constraint (" + constraintRef + ") does not hard-code a constraint weight"
+ " and there is no @" + ConstraintConfigurationProvider.class.getSimpleName()
+ " on the solution class (" + solutionDescriptor.getSolutionClass() + ").\n"
+ "Maybe add a @" + ConstraintConfiguration.class.getSimpleName() + " class"
+ " or use " + ConstraintStream.class.getSimpleName() + ".penalize()/reward()"
+ " instead of penalizeConfigurable()/rewardConfigurable.");
}
ConstraintWeightDescriptor<Solution_> weightDescriptor = configurationDescriptor
.findConstraintWeightDescriptor(constraintRef);
if (weightDescriptor == null) {
throw new IllegalStateException("The constraint (" + constraintRef + ") does not hard-code a constraint weight"
+ " and there is no such @" + ConstraintWeight.class.getSimpleName()
+ " on the constraintConfigurationClass (" + configurationDescriptor.getConstraintConfigurationClass()
+ ").\n"
+ "Maybe there is a typo in the constraintPackage or constraintName of one of the @"
+ ConstraintWeight.class.getSimpleName() + " members.\n"
+ "Maybe add a @" + ConstraintWeight.class.getSimpleName() + " member for it.");
}
return weightDescriptor.createExtractor();
}
protected Function<Solution_, Score<?>> buildConstraintWeightExtractor(ConstraintRef constraintRef,
Score<?> constraintWeight) {
// Duplicates validation when the session is built, but this fails fast when weights are hard coded
getConstraintFactory().getSolutionDescriptor().validateConstraintWeight(constraintRef, constraintWeight);
return solution -> constraintWeight;
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public abstract InnerConstraintFactory<Solution_, ?> getConstraintFactory();
protected abstract <JustificationMapping_> JustificationMapping_ getDefaultJustificationMapping();
protected abstract <IndictedObjectsMapping_> IndictedObjectsMapping_ getDefaultIndictedObjectsMapping();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/AbstractConstraintStreamScoreDirectorFactory.java | package ai.timefold.solver.constraint.streams.common;
import ai.timefold.solver.constraint.streams.common.inliner.AbstractScoreInliner;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactory;
/**
* FP streams implementation of {@link ScoreDirectorFactory}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @param <Score_> the score type to go with the solution
* @see ScoreDirectorFactory
*/
public abstract class AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_ extends Score<Score_>>
extends AbstractScoreDirectorFactory<Solution_, Score_> {
protected AbstractConstraintStreamScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor) {
super(solutionDescriptor);
}
/**
* Creates a new score director, inserts facts and calculates score.
*
* @param facts never null
* @return never null
*/
public abstract AbstractScoreInliner<Score_> fireAndForget(Object... facts);
public abstract Constraint[] getConstraints();
@Override
public boolean supportsConstraintMatching() {
return true;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/AbstractConstraintStreamScoreDirectorFactoryService.java | package ai.timefold.solver.constraint.streams.common;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactoryService;
public abstract class AbstractConstraintStreamScoreDirectorFactoryService<Solution_, Score_ extends Score<Score_>>
implements ScoreDirectorFactoryService<Solution_, Score_> {
public abstract AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_> buildScoreDirectorFactory(
SolutionDescriptor<Solution_> solutionDescriptor, ConstraintProvider constraintProvider,
EnvironmentMode environmentMode);
public abstract ConstraintFactory buildConstraintFactory(SolutionDescriptor<Solution_> solutionDescriptor,
EnvironmentMode environmentMode);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/AbstractJoiner.java | package ai.timefold.solver.constraint.streams.common;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public abstract class AbstractJoiner<Right_> {
protected final Function<Right_, Object>[] rightMappings;
protected final JoinerType[] joinerTypes;
protected <Property_> AbstractJoiner(Function<Right_, Property_> rightMapping, JoinerType joinerType) {
this(new Function[] { rightMapping }, new JoinerType[] { joinerType });
}
protected <Property_> AbstractJoiner(Function<Right_, Property_>[] rightMappings, JoinerType[] joinerTypes) {
this.rightMappings = (Function<Right_, Object>[]) Objects.requireNonNull(rightMappings);
this.joinerTypes = Objects.requireNonNull(joinerTypes);
}
public final Function<Right_, Object> getRightMapping(int index) {
return rightMappings[index];
}
public final int getJoinerCount() {
return joinerTypes.length;
}
public final JoinerType getJoinerType(int index) {
return joinerTypes[index];
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/ConstraintConstructor.java | package ai.timefold.solver.constraint.streams.common;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
@FunctionalInterface
public interface ConstraintConstructor<Score_ extends Score<Score_>, JustificationMapping_, IndictedObjectsMapping_> {
Constraint apply(String constraintPackage, String constraintName, Score_ constraintWeight,
ScoreImpactType impactType, JustificationMapping_ justificationMapping,
IndictedObjectsMapping_ indictedObjectsMapping);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/DefaultJoinerService.java | package ai.timefold.solver.constraint.streams.common;
import java.util.function.BiFunction;
import java.util.function.BiPredicate;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.bi.DefaultBiJoiner;
import ai.timefold.solver.constraint.streams.common.bi.FilteringBiJoiner;
import ai.timefold.solver.constraint.streams.common.penta.DefaultPentaJoiner;
import ai.timefold.solver.constraint.streams.common.penta.FilteringPentaJoiner;
import ai.timefold.solver.constraint.streams.common.quad.DefaultQuadJoiner;
import ai.timefold.solver.constraint.streams.common.quad.FilteringQuadJoiner;
import ai.timefold.solver.constraint.streams.common.tri.DefaultTriJoiner;
import ai.timefold.solver.constraint.streams.common.tri.FilteringTriJoiner;
import ai.timefold.solver.core.api.function.PentaPredicate;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerService;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultJoinerService implements JoinerService {
@Override
public <A, B> BiJoiner<A, B> newBiJoiner(BiPredicate<A, B> filter) {
return new FilteringBiJoiner<>(filter);
}
@Override
public <A, B, Property_> BiJoiner<A, B> newBiJoiner(Function<A, Property_> leftMapping, JoinerType joinerType,
Function<B, Property_> rightMapping) {
return new DefaultBiJoiner<>(leftMapping, joinerType, rightMapping);
}
@Override
public <A, B, C> TriJoiner<A, B, C> newTriJoiner(TriPredicate<A, B, C> filter) {
return new FilteringTriJoiner<>(filter);
}
@Override
public <A, B, C, Property_> TriJoiner<A, B, C> newTriJoiner(BiFunction<A, B, Property_> leftMapping, JoinerType joinerType,
Function<C, Property_> rightMapping) {
return new DefaultTriJoiner<>(leftMapping, joinerType, rightMapping);
}
@Override
public <A, B, C, D> QuadJoiner<A, B, C, D> newQuadJoiner(QuadPredicate<A, B, C, D> filter) {
return new FilteringQuadJoiner<>(filter);
}
@Override
public <A, B, C, D, Property_> QuadJoiner<A, B, C, D> newQuadJoiner(TriFunction<A, B, C, Property_> leftMapping,
JoinerType joinerType, Function<D, Property_> rightMapping) {
return new DefaultQuadJoiner<>(leftMapping, joinerType, rightMapping);
}
@Override
public <A, B, C, D, E> PentaJoiner<A, B, C, D, E> newPentaJoiner(PentaPredicate<A, B, C, D, E> filter) {
return new FilteringPentaJoiner<>(filter);
}
@Override
public <A, B, C, D, E, Property_> PentaJoiner<A, B, C, D, E> newPentaJoiner(QuadFunction<A, B, C, D, Property_> leftMapping,
JoinerType joinerType, Function<E, Property_> rightMapping) {
return new DefaultPentaJoiner<>(leftMapping, joinerType, rightMapping);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/InnerConstraintFactory.java | package ai.timefold.solver.constraint.streams.common;
import static ai.timefold.solver.core.api.score.stream.Joiners.lessThan;
import static java.util.stream.Collectors.groupingBy;
import static java.util.stream.Collectors.toList;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import ai.timefold.solver.constraint.streams.common.bi.BiJoinerComber;
import ai.timefold.solver.constraint.streams.common.bi.DefaultBiJoiner;
import ai.timefold.solver.constraint.streams.common.uni.InnerUniConstraintStream;
import ai.timefold.solver.core.api.domain.lookup.PlanningId;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
public abstract class InnerConstraintFactory<Solution_, Constraint_ extends Constraint> implements ConstraintFactory {
@Override
public <A> BiConstraintStream<A, A> forEachUniquePair(Class<A> sourceClass, BiJoiner<A, A>... joiners) {
BiJoinerComber<A, A> joinerComber = BiJoinerComber.comb(joiners);
joinerComber.addJoiner(buildLessThanId(sourceClass));
return ((InnerUniConstraintStream<A>) forEach(sourceClass))
.join(forEach(sourceClass), joinerComber);
}
private <A> DefaultBiJoiner<A, A> buildLessThanId(Class<A> sourceClass) {
SolutionDescriptor<Solution_> solutionDescriptor = getSolutionDescriptor();
MemberAccessor planningIdMemberAccessor = solutionDescriptor.getPlanningIdAccessor(sourceClass);
if (planningIdMemberAccessor == null) {
throw new IllegalArgumentException("The fromClass (" + sourceClass + ") has no member with a @"
+ PlanningId.class.getSimpleName() + " annotation,"
+ " so the pairs cannot be made unique ([A,B] vs [B,A]).");
}
Function<A, Comparable> planningIdGetter = planningIdMemberAccessor.getGetterFunction();
return (DefaultBiJoiner<A, A>) lessThan(planningIdGetter);
}
@Override
public <A> BiConstraintStream<A, A> fromUniquePair(Class<A> fromClass, BiJoiner<A, A>... joiners) {
BiJoinerComber<A, A> joinerComber = BiJoinerComber.comb(joiners);
joinerComber.addJoiner(buildLessThanId(fromClass));
return ((InnerUniConstraintStream<A>) from(fromClass))
.join(from(fromClass), joinerComber);
}
public <A> void assertValidFromType(Class<A> fromType) {
SolutionDescriptor<Solution_> solutionDescriptor = getSolutionDescriptor();
Set<Class<?>> problemFactOrEntityClassSet = solutionDescriptor.getProblemFactOrEntityClassSet();
/*
* Need to support the following situations:
* 1/ FactType == FromType; querying for the declared type.
* 2/ FromType extends/implements FactType; querying for impl type where declared type is its interface.
* 3/ FromType super FactType; querying for interface where declared type is its implementation.
*/
boolean hasMatchingType = problemFactOrEntityClassSet.stream()
.anyMatch(factType -> fromType.isAssignableFrom(factType) || factType.isAssignableFrom(fromType));
if (!hasMatchingType) {
List<String> canonicalClassNameList = problemFactOrEntityClassSet.stream()
.map(Class::getCanonicalName)
.sorted()
.collect(toList());
throw new IllegalArgumentException("Cannot use class (" + fromType.getCanonicalName()
+ ") in a constraint stream as it is neither the same as, nor a superclass or superinterface of "
+ "one of planning entities or problem facts.\n"
+ "Ensure that all from(), join(), ifExists() and ifNotExists() building blocks only reference "
+ "classes assignable from planning entities or problem facts (" + canonicalClassNameList + ") "
+ "annotated on the planning solution (" + solutionDescriptor.getSolutionClass().getCanonicalName()
+ ").");
}
}
public List<Constraint_> buildConstraints(ConstraintProvider constraintProvider) {
Constraint[] constraints = constraintProvider.defineConstraints(this);
if (constraints == null) {
throw new IllegalStateException("The constraintProvider class (" + constraintProvider.getClass()
+ ")'s defineConstraints() must not return null.\n"
+ "Maybe return an empty array instead if there are no constraints.");
}
if (Arrays.stream(constraints).anyMatch(Objects::isNull)) {
throw new IllegalStateException("The constraintProvider class (" + constraintProvider.getClass()
+ ")'s defineConstraints() must not contain an element that is null.\n"
+ "Maybe don't include any null elements in the " + Constraint.class.getSimpleName() + " array.");
}
// Fail fast on duplicate constraint IDs.
Map<ConstraintRef, List<Constraint>> constraintsPerIdMap =
Arrays.stream(constraints).collect(groupingBy(Constraint::getConstraintRef));
constraintsPerIdMap.forEach((constraintRef, duplicateConstraintList) -> {
if (duplicateConstraintList.size() > 1) {
throw new IllegalStateException("There are multiple constraints with the same ID (" + constraintRef + ").");
}
});
return Arrays.stream(constraints)
.map(c -> (Constraint_) c)
.collect(Collectors.toList());
}
/**
* @return never null
*/
public abstract SolutionDescriptor<Solution_> getSolutionDescriptor();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/RetrievalSemantics.java | package ai.timefold.solver.constraint.streams.common;
import ai.timefold.solver.core.api.domain.variable.PlanningVariable;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
/**
* Determines the behavior of joins and conditional propagation
* based on whether they are coming off of a constraint stream started by
* either {@link ConstraintFactory#from(Class)}
* or {@link ConstraintFactory#forEach(Class)}
* family of methods.
*
* <p>
* For classes which are not planning entities, all of their instances are always retrieved.
* For classes which are planning entities,
* the difference in behavior depends on whether they use planning variables which allow unassigned values.
*
* @see PlanningVariable#allowsUnassigned()
*/
public enum RetrievalSemantics {
/**
* Joins do not include entities with null planning variables,
* unless specifically requested by join(forEachIncludingUnassigned(...)).
* Conditional propagation does not include null planning variables,
* unless specifically requested using a *IncludingUnassigned() method overload.
*
* <p>
* Applies when the stream comes off of a {@link ConstraintFactory#forEach(Class)} family of methods.
*/
STANDARD,
/**
* Joins include entities with null planning variables if these variables allow unassigned values.
* Conditional propagation always includes entities with null planning variables,
* regardless of whether their planning variables allow unassigned values.
*
* <p>
* Applies when the stream comes off of a {@link ConstraintFactory#from(Class)}
* family of methods.
*
* @deprecated this semantics is deprecated and kept around for backward compatibility reasons.
* It will be removed in 2.0, together with the from() family of methods, along with this entire enum.
*/
@Deprecated(forRemoval = true)
LEGACY
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/ScoreImpactType.java | package ai.timefold.solver.constraint.streams.common;
public enum ScoreImpactType {
REWARD,
PENALTY,
MIXED
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/bi/BiConstraintBuilderImpl.java | package ai.timefold.solver.constraint.streams.common.bi;
import java.util.Collection;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintBuilder;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintBuilder;
public final class BiConstraintBuilderImpl<A, B, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements BiConstraintBuilder<A, B, Score_> {
private TriFunction<A, B, Score_, ConstraintJustification> justificationMapping;
private BiFunction<A, B, Collection<Object>> indictedObjectsMapping;
public BiConstraintBuilderImpl(BiConstraintConstructor<A, B, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected TriFunction<A, B, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> BiConstraintBuilder<A, B, Score_> justifyWith(
TriFunction<A, B, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("""
Justification mapping already set (%s).
Maybe the constraint calls justifyWith() twice?"""
.formatted(justificationMapping));
}
this.justificationMapping =
(TriFunction<A, B, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected BiFunction<A, B, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public BiConstraintBuilder<A, B, Score_> indictWith(BiFunction<A, B, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("""
Indicted objects' mapping already set (%s).
Maybe the constraint calls indictWith() twice?"""
.formatted(indictedObjectsMapping));
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/bi/BiConstraintConstructor.java | package ai.timefold.solver.constraint.streams.common.bi;
import java.util.Collection;
import java.util.function.BiFunction;
import ai.timefold.solver.constraint.streams.common.ConstraintConstructor;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
@FunctionalInterface
public interface BiConstraintConstructor<A, B, Score_ extends Score<Score_>>
extends ConstraintConstructor<Score_, TriFunction<A, B, Score_, Object>, BiFunction<A, B, Collection<?>>> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/bi/BiJoinerComber.java | package ai.timefold.solver.constraint.streams.common.bi;
import java.util.ArrayList;
import java.util.List;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
/**
* Combs an array of {@link BiJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
*/
public final class BiJoinerComber<A, B> {
public static <A, B> BiJoinerComber<A, B> comb(BiJoiner<A, B>[] joiners) {
List<DefaultBiJoiner<A, B>> defaultJoinerList = new ArrayList<>(joiners.length);
List<BiPredicate<A, B>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
BiJoiner<A, B> joiner = joiners[i];
if (joiner instanceof FilteringBiJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringBiJoiner<A, B>) joiner).getFilter());
} else if (joiner instanceof DefaultBiJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultBiJoiner<A, B>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultBiJoiner<A, B> mergedJoiner = DefaultBiJoiner.merge(defaultJoinerList);
BiPredicate<A, B> mergedFiltering = mergeFiltering(filteringList);
return new BiJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <A, B> BiPredicate<A, B> mergeFiltering(List<BiPredicate<A, B>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b) -> {
for (BiPredicate<A, B> predicate : filteringList) {
if (!predicate.test(a, b)) {
return false;
}
}
return true;
};
}
}
private DefaultBiJoiner<A, B> mergedJoiner;
private final BiPredicate<A, B> mergedFiltering;
public BiJoinerComber(DefaultBiJoiner<A, B> mergedJoiner, BiPredicate<A, B> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultBiJoiner<A, B> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public BiPredicate<A, B> getMergedFiltering() {
return mergedFiltering;
}
public void addJoiner(DefaultBiJoiner<A, B> extraJoiner) {
mergedJoiner = mergedJoiner.and(extraJoiner);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/bi/DefaultBiJoiner.java | package ai.timefold.solver.constraint.streams.common.bi;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultBiJoiner<A, B> extends AbstractJoiner<B> implements BiJoiner<A, B> {
private static final DefaultBiJoiner NONE = new DefaultBiJoiner(new Function[0], new JoinerType[0], new Function[0]);
private final Function<A, ?>[] leftMappings;
public <Property_> DefaultBiJoiner(Function<A, Property_> leftMapping, JoinerType joinerType,
Function<B, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new Function[] { leftMapping };
}
private <Property_> DefaultBiJoiner(Function<A, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<B, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B> DefaultBiJoiner<A, B> merge(List<DefaultBiJoiner<A, B>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultBiJoiner::and);
}
@Override
public DefaultBiJoiner<A, B> and(BiJoiner<A, B> otherJoiner) {
DefaultBiJoiner<A, B> castJoiner = (DefaultBiJoiner<A, B>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
Function[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoinerCount; i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultBiJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public Function<A, Object> getLeftMapping(int index) {
return (Function<A, Object>) leftMappings[index];
}
public boolean matches(A a, B b) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a);
Object rightMapping = getRightMapping(i).apply(b);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (o instanceof DefaultBiJoiner<?, ?> other) {
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/bi/FilteringBiJoiner.java | package ai.timefold.solver.constraint.streams.common.bi;
import java.util.Objects;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
public final class FilteringBiJoiner<A, B> implements BiJoiner<A, B> {
private final BiPredicate<A, B> filter;
public FilteringBiJoiner(BiPredicate<A, B> filter) {
this.filter = filter;
}
@Override
public FilteringBiJoiner<A, B> and(BiJoiner<A, B> otherJoiner) {
FilteringBiJoiner<A, B> castJoiner = (FilteringBiJoiner<A, B>) otherJoiner;
return new FilteringBiJoiner<>(filter.and(castJoiner.getFilter()));
}
public BiPredicate<A, B> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof FilteringBiJoiner)) {
return false;
}
FilteringBiJoiner<?, ?> other = (FilteringBiJoiner<?, ?>) o;
return Objects.equals(filter, other.filter);
}
@Override
public int hashCode() {
return Objects.hash(filter);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/bi/InnerBiConstraintStream.java | package ai.timefold.solver.constraint.streams.common.bi;
import static ai.timefold.solver.constraint.streams.common.RetrievalSemantics.STANDARD;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.ToIntBiFunction;
import java.util.function.ToLongBiFunction;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
public interface InnerBiConstraintStream<A, B> extends BiConstraintStream<A, B> {
static <A, B> TriFunction<A, B, Score<?>, DefaultConstraintJustification> createDefaultJustificationMapping() {
return (a, b, score) -> DefaultConstraintJustification.of(score, a, b);
}
static <A, B> BiFunction<A, B, Collection<?>> createDefaultIndictedObjectsMapping() {
return Arrays::asList;
}
RetrievalSemantics getRetrievalSemantics();
/**
* This method will return true if the constraint stream is guaranteed to only produce distinct tuples.
* See {@link #distinct()} for details.
*
* @return true if the guarantee of distinct tuples is provided
*/
boolean guaranteesDistinct();
@Override
default <C> TriConstraintStream<A, B, C> join(Class<C> otherClass, TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == STANDARD) {
return join(getConstraintFactory().forEach(otherClass), joiners);
} else {
return join(getConstraintFactory().from(otherClass), joiners);
}
}
@Override
default BiConstraintStream<A, B> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy((a, b) -> a, (a, b) -> b);
}
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> penalize(Score_ constraintWeight,
ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> penalizeLong(Score_ constraintWeight,
ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> penalizeBigDecimal(Score_ constraintWeight,
BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default BiConstraintBuilder<A, B, ?> penalizeConfigurable(ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default BiConstraintBuilder<A, B, ?> penalizeConfigurableLong(ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default BiConstraintBuilder<A, B, ?> penalizeConfigurableBigDecimal(BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> reward(Score_ constraintWeight,
ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> rewardLong(Score_ constraintWeight,
ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> rewardBigDecimal(Score_ constraintWeight,
BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default BiConstraintBuilder<A, B, ?> rewardConfigurable(ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default BiConstraintBuilder<A, B, ?> rewardConfigurableLong(ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default BiConstraintBuilder<A, B, ?> rewardConfigurableBigDecimal(BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> impact(Score_ constraintWeight,
ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> impactLong(Score_ constraintWeight,
ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> impactBigDecimal(Score_ constraintWeight,
BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default BiConstraintBuilder<A, B, ?> impactConfigurable(ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default BiConstraintBuilder<A, B, ?> impactConfigurableLong(ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default BiConstraintBuilder<A, B, ?> impactConfigurableBigDecimal(BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
ToIntBiFunction<A, B> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
ToLongBiFunction<A, B> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
BiFunction<A, B, BigDecimal> matchWeigher,
ScoreImpactType scoreImpactType);
@Override
default Constraint penalize(String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint penalize(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint reward(String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint reward(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint impact(String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint impact(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/AbstractScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.lang.reflect.InvocationTargetException;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.TreeMap;
import java.util.function.Supplier;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatch;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatchTotal;
import ai.timefold.solver.core.api.score.constraint.Indictment;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.score.buildin.BendableBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.BendableLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.BendableScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardMediumSoftBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardMediumSoftLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardMediumSoftScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardSoftBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardSoftLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardSoftScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.SimpleBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.SimpleLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.SimpleScoreDefinition;
import ai.timefold.solver.core.impl.score.constraint.DefaultConstraintMatchTotal;
import ai.timefold.solver.core.impl.score.constraint.DefaultIndictment;
import ai.timefold.solver.core.impl.score.definition.ScoreDefinition;
import ai.timefold.solver.core.impl.util.CollectionUtils;
import ai.timefold.solver.core.impl.util.ElementAwareList;
import ai.timefold.solver.core.impl.util.ElementAwareListEntry;
/**
* Keeps track of the working score and constraint matches for a single constraint session.
* Every time constraint weights change, a new instance needs to be created.
*
* @param <Score_>
*/
public abstract class AbstractScoreInliner<Score_ extends Score<Score_>> {
@Deprecated(forRemoval = true)
private static final String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME =
"ai.timefold.solver.score.stream.inliner";
public static <Score_ extends Score<Score_>, ScoreInliner_ extends AbstractScoreInliner<Score_>> ScoreInliner_
buildScoreInliner(ScoreDefinition<Score_> scoreDefinition, Map<Constraint, Score_> constraintWeightMap,
boolean constraintMatchEnabled) {
if (scoreDefinition instanceof SimpleScoreDefinition) {
return (ScoreInliner_) new SimpleScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof SimpleLongScoreDefinition) {
return (ScoreInliner_) new SimpleLongScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof SimpleBigDecimalScoreDefinition) {
return (ScoreInliner_) new SimpleBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof HardSoftScoreDefinition) {
return (ScoreInliner_) new HardSoftScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof HardSoftLongScoreDefinition) {
return (ScoreInliner_) new HardSoftLongScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof HardSoftBigDecimalScoreDefinition) {
return (ScoreInliner_) new HardSoftBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof HardMediumSoftScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof HardMediumSoftLongScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftLongScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof HardMediumSoftBigDecimalScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchEnabled);
} else if (scoreDefinition instanceof BendableScoreDefinition bendableScoreDefinition) {
return (ScoreInliner_) new BendableScoreInliner((Map) constraintWeightMap, constraintMatchEnabled,
bendableScoreDefinition.getHardLevelsSize(),
bendableScoreDefinition.getSoftLevelsSize());
} else if (scoreDefinition instanceof BendableLongScoreDefinition bendableScoreDefinition) {
return (ScoreInliner_) new BendableLongScoreInliner((Map) constraintWeightMap, constraintMatchEnabled,
bendableScoreDefinition.getHardLevelsSize(),
bendableScoreDefinition.getSoftLevelsSize());
} else if (scoreDefinition instanceof BendableBigDecimalScoreDefinition bendableScoreDefinition) {
return (ScoreInliner_) new BendableBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchEnabled,
bendableScoreDefinition.getHardLevelsSize(), bendableScoreDefinition.getSoftLevelsSize());
} else {
String customScoreInlinerClassName = System.getProperty(CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME);
if (customScoreInlinerClassName == null) {
throw new UnsupportedOperationException("Unknown score definition class (" +
scoreDefinition.getClass().getCanonicalName() + ").\n" +
"If you're attempting to use a custom score, " +
"provide your " + AbstractScoreInliner.class.getSimpleName() + " implementation using the '" +
CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME + "' system property.\n" +
"Note: support for custom scores will be removed in Timefold 2.0.");
}
try {
Class<?> customScoreInlinerClass = Class.forName(customScoreInlinerClassName);
if (!AbstractScoreInliner.class.isAssignableFrom(customScoreInlinerClass)) {
throw new IllegalStateException("Custom score inliner class (" + customScoreInlinerClassName +
") does not extend " + AbstractScoreInliner.class.getCanonicalName() + ".\n" +
"Note: support for custom scores will be removed in Timefold 2.0.");
}
return ((Class<ScoreInliner_>) customScoreInlinerClass).getConstructor()
.newInstance();
} catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException
| InvocationTargetException cause) {
throw new IllegalStateException("Custom score inliner class (" + customScoreInlinerClassName +
") can not be instantiated.\n" +
"Maybe add a no-arg public constructor?\n" +
"Note: support for custom scores will be removed in Timefold 2.0.", cause);
}
}
}
protected final boolean constraintMatchEnabled;
protected final Map<Constraint, Score_> constraintWeightMap;
private final Map<Constraint, ElementAwareList<ConstraintMatchCarrier<Score_>>> constraintMatchMap;
private Map<String, ConstraintMatchTotal<Score_>> constraintIdToConstraintMatchTotalMap = null;
private Map<Object, Indictment<Score_>> indictmentMap = null;
protected AbstractScoreInliner(Map<Constraint, Score_> constraintWeightMap, boolean constraintMatchEnabled) {
this.constraintMatchEnabled = constraintMatchEnabled;
constraintWeightMap.forEach(this::validateConstraintWeight);
this.constraintWeightMap = constraintWeightMap;
this.constraintMatchMap =
constraintMatchEnabled ? CollectionUtils.newIdentityHashMap(constraintWeightMap.size()) : null;
if (constraintMatchEnabled) {
for (var constraint : constraintWeightMap.keySet()) {
// Ensure that even constraints without matches have their entry.
constraintMatchMap.put(constraint, new ElementAwareList<>());
}
}
}
private void validateConstraintWeight(Constraint constraint, Score_ constraintWeight) {
if (constraintWeight == null || constraintWeight.isZero()) {
throw new IllegalArgumentException("Impossible state: The constraintWeight (" +
constraintWeight + ") cannot be zero, constraint (" + constraint +
") should have been culled during session creation.");
}
}
public abstract Score_ extractScore(int initScore);
/**
* Create a new instance of {@link WeightedScoreImpacter} for a particular constraint.
*
* @param constraint never null
* @return never null
*/
public abstract WeightedScoreImpacter<Score_, ?> buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint);
protected final UndoScoreImpacter addConstraintMatch(Constraint constraint, Score_ score,
ConstraintMatchSupplier<Score_> constraintMatchSupplier, UndoScoreImpacter undoScoreImpact) {
ElementAwareList<ConstraintMatchCarrier<Score_>> constraintMatchList = getConstraintMatchList(constraint);
/*
* Creating a constraint match is a heavy operation which may yet be undone.
* Defer creation of the constraint match until a later point.
*/
ElementAwareListEntry<ConstraintMatchCarrier<Score_>> entry =
constraintMatchList.add(new ConstraintMatchCarrier<>(constraintMatchSupplier, constraint, score));
clearMaps();
return () -> {
undoScoreImpact.run();
entry.remove();
clearMaps();
};
}
private ElementAwareList<ConstraintMatchCarrier<Score_>> getConstraintMatchList(Constraint constraint) {
// Optimization: computeIfAbsent() would have created a lambda on the hot path.
ElementAwareList<ConstraintMatchCarrier<Score_>> constraintMatchList = constraintMatchMap.get(constraint);
if (constraintMatchList == null) {
throw new IllegalStateException(
"Impossible state: Unknown constraint (%s)."
.formatted(constraint.getConstraintRef()));
}
return constraintMatchList;
}
private void clearMaps() {
constraintIdToConstraintMatchTotalMap = null;
indictmentMap = null;
}
public boolean isConstraintMatchEnabled() {
return constraintMatchEnabled;
}
public final Map<String, ConstraintMatchTotal<Score_>> getConstraintIdToConstraintMatchTotalMap() {
if (constraintIdToConstraintMatchTotalMap == null) {
rebuildConstraintMatchTotals();
}
return constraintIdToConstraintMatchTotalMap;
}
private void rebuildConstraintMatchTotals() {
var constraintIdToConstraintMatchTotalMap = new TreeMap<String, ConstraintMatchTotal<Score_>>();
for (var entry : constraintMatchMap.entrySet()) {
var constraint = entry.getKey();
var constraintMatchTotal =
new DefaultConstraintMatchTotal<>(constraint.getConstraintRef(), constraintWeightMap.get(constraint));
for (var carrier : entry.getValue()) {
// Constraint match instances are only created here when we actually need them.
var constraintMatch = carrier.get();
constraintMatchTotal.addConstraintMatch(constraintMatch);
}
constraintIdToConstraintMatchTotalMap.put(constraint.getConstraintRef().constraintId(), constraintMatchTotal);
}
this.constraintIdToConstraintMatchTotalMap = constraintIdToConstraintMatchTotalMap;
}
public final Map<Object, Indictment<Score_>> getIndictmentMap() {
if (indictmentMap == null) {
rebuildIndictments();
}
return indictmentMap;
}
private void rebuildIndictments() {
var workingIndictmentMap = new LinkedHashMap<Object, Indictment<Score_>>();
for (var entry : constraintMatchMap.entrySet()) {
for (var carrier : entry.getValue()) {
// Constraint match instances are only created here when we actually need them.
var constraintMatch = carrier.get();
for (var indictedObject : constraintMatch.getIndictedObjectList()) {
if (indictedObject == null) { // Users may have sent null, or it came from the default mapping.
continue;
}
var indictment =
(DefaultIndictment<Score_>) getIndictment(workingIndictmentMap, constraintMatch, indictedObject);
/*
* Optimization: In order to not have to go over the indicted object list and remove duplicates,
* we use a method that will silently skip duplicate constraint matches.
* This is harmless because the two identical indicted objects come from the same constraint match.
*/
indictment.addConstraintMatchWithoutFail(constraintMatch);
}
}
}
indictmentMap = workingIndictmentMap;
}
private DefaultIndictment<Score_> getIndictment(Map<Object, Indictment<Score_>> indictmentMap,
ConstraintMatch<Score_> constraintMatch, Object indictedObject) {
// Like computeIfAbsent(), but doesn't create a capturing lambda on the hot path.
var indictment = (DefaultIndictment<Score_>) indictmentMap.get(indictedObject);
if (indictment == null) {
indictment = new DefaultIndictment<>(indictedObject, constraintMatch.getScore().zero());
indictmentMap.put(indictedObject, indictment);
}
return indictment;
}
private static final class ConstraintMatchCarrier<Score_ extends Score<Score_>>
implements
Supplier<ConstraintMatch<Score_>> {
private final Constraint constraint;
private final ConstraintMatchSupplier<Score_> constraintMatchSupplier;
private final Score_ score;
private ConstraintMatch<Score_> constraintMatch;
private ConstraintMatchCarrier(ConstraintMatchSupplier<Score_> constraintMatchSupplier, Constraint constraint,
Score_ score) {
this.constraint = constraint;
this.constraintMatchSupplier = constraintMatchSupplier;
this.score = score;
}
@Override
public ConstraintMatch<Score_> get() {
if (constraintMatch == null) {
// Repeated requests for score explanation should not create the same constraint match over and over.
constraintMatch = constraintMatchSupplier.apply(constraint, score);
}
return constraintMatch;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/BendableBigDecimalScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
final class BendableBigDecimalScoreContext extends ScoreContext<BendableBigDecimalScore, BendableBigDecimalScoreInliner> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final BigDecimal scoreLevelWeight;
public BendableBigDecimalScoreContext(BendableBigDecimalScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableBigDecimalScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
BigDecimal scoreLevelWeight) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
}
public BendableBigDecimalScoreContext(BendableBigDecimalScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableBigDecimalScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, BigDecimal.ZERO);
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<BendableBigDecimalScore> constraintMatchSupplier) {
BigDecimal softImpact = scoreLevelWeight.multiply(matchWeight);
parent.softScores[scoreLevel] = parent.softScores[scoreLevel].add(softImpact);
UndoScoreImpacter undoScoreImpact =
() -> parent.softScores[scoreLevel] = parent.softScores[scoreLevel].subtract(softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableBigDecimalScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<BendableBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = scoreLevelWeight.multiply(matchWeight);
parent.hardScores[scoreLevel] = parent.hardScores[scoreLevel].add(hardImpact);
UndoScoreImpacter undoScoreImpact =
() -> parent.hardScores[scoreLevel] = parent.hardScores[scoreLevel].subtract(hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableBigDecimalScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<BendableBigDecimalScore> constraintMatchSupplier) {
BigDecimal[] hardImpacts = new BigDecimal[hardScoreLevelCount];
BigDecimal[] softImpacts = new BigDecimal[softScoreLevelCount];
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
BigDecimal hardImpact = constraintWeight.hardScore(hardScoreLevel).multiply(matchWeight);
hardImpacts[hardScoreLevel] = hardImpact;
parent.hardScores[hardScoreLevel] = parent.hardScores[hardScoreLevel].add(hardImpact);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
BigDecimal softImpact = constraintWeight.softScore(softScoreLevel).multiply(matchWeight);
softImpacts[softScoreLevel] = softImpact;
parent.softScores[softScoreLevel] = parent.softScores[softScoreLevel].add(softImpact);
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
parent.hardScores[hardScoreLevel] = parent.hardScores[hardScoreLevel].subtract(hardImpacts[hardScoreLevel]);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
parent.softScores[softScoreLevel] = parent.softScores[softScoreLevel].subtract(softImpacts[softScoreLevel]);
}
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableBigDecimalScore.of(hardImpacts, softImpacts),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/BendableBigDecimalScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class BendableBigDecimalScoreInliner extends AbstractScoreInliner<BendableBigDecimalScore> {
final BigDecimal[] hardScores;
final BigDecimal[] softScores;
BendableBigDecimalScoreInliner(Map<Constraint, BendableBigDecimalScore> constraintWeightMap, boolean constraintMatchEnabled,
int hardLevelsSize, int softLevelsSize) {
super(constraintWeightMap, constraintMatchEnabled);
hardScores = new BigDecimal[hardLevelsSize];
Arrays.fill(hardScores, BigDecimal.ZERO);
softScores = new BigDecimal[softLevelsSize];
Arrays.fill(softScores, BigDecimal.ZERO);
}
@Override
public WeightedScoreImpacter<BendableBigDecimalScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
Integer singleLevel = null;
BendableBigDecimalScore constraintWeight = constraintWeightMap.get(constraint);
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (!constraintWeight.hardOrSoftScore(i).equals(BigDecimal.ZERO)) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableBigDecimalScoreContext context = new BendableBigDecimalScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel));
if (isHardScore) {
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeHardScoreBy);
} else {
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeSoftScoreBy);
}
} else {
BendableBigDecimalScoreContext context = new BendableBigDecimalScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length);
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeScoreBy);
}
}
@Override
public BendableBigDecimalScore extractScore(int initScore) {
return BendableBigDecimalScore.ofUninitialized(initScore,
Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/BendableLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
final class BendableLongScoreContext extends ScoreContext<BendableLongScore, BendableLongScoreInliner> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final long scoreLevelWeight;
public BendableLongScoreContext(BendableLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableLongScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
long scoreLevelWeight) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
}
public BendableLongScoreContext(BendableLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableLongScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, -1);
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) {
long softImpact = scoreLevelWeight * matchWeight;
parent.softScores[scoreLevel] += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScores[scoreLevel] -= softImpact;
;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableLongScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) {
long hardImpact = scoreLevelWeight * matchWeight;
parent.hardScores[scoreLevel] += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScores[scoreLevel] -= hardImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableLongScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) {
long[] hardImpacts = new long[hardScoreLevelCount];
long[] softImpacts = new long[softScoreLevelCount];
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
long hardImpact = constraintWeight.hardScore(hardScoreLevel) * matchWeight;
hardImpacts[hardScoreLevel] = hardImpact;
parent.hardScores[hardScoreLevel] += hardImpact;
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
long softImpact = constraintWeight.softScore(softScoreLevel) * matchWeight;
softImpacts[softScoreLevel] = softImpact;
parent.softScores[softScoreLevel] += softImpact;
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
parent.hardScores[hardScoreLevel] -= hardImpacts[hardScoreLevel];
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
parent.softScores[softScoreLevel] -= softImpacts[softScoreLevel];
}
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableLongScore.of(hardImpacts, softImpacts),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/BendableLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Arrays;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
public final class BendableLongScoreInliner extends AbstractScoreInliner<BendableLongScore> {
final long[] hardScores;
final long[] softScores;
BendableLongScoreInliner(Map<Constraint, BendableLongScore> constraintWeightMap, boolean constraintMatchEnabled,
int hardLevelsSize, int softLevelsSize) {
super(constraintWeightMap, constraintMatchEnabled);
hardScores = new long[hardLevelsSize];
softScores = new long[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableLongScore, ?> buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
Integer singleLevel = null;
BendableLongScore constraintWeight = constraintWeightMap.get(constraint);
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableLongScoreContext context = new BendableLongScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel));
if (isHardScore) {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) -> ctx.changeHardScoreBy(impact,
constraintMatchSupplier));
} else {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) -> ctx.changeSoftScoreBy(impact,
constraintMatchSupplier));
}
} else {
BendableLongScoreContext context =
new BendableLongScoreContext(this, constraint, constraintWeight, hardScores.length, softScores.length);
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) -> ctx.changeScoreBy(impact,
constraintMatchSupplier));
}
}
@Override
public BendableLongScore extractScore(int initScore) {
return BendableLongScore.ofUninitialized(initScore,
Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/BendableScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
final class BendableScoreContext extends ScoreContext<BendableScore, BendableScoreInliner> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final int scoreLevelWeight;
public BendableScoreContext(BendableScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
int scoreLevelWeight) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
}
public BendableScoreContext(BendableScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, -1);
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight,
ConstraintMatchSupplier<BendableScore> constraintMatchSupplier) {
int softImpact = scoreLevelWeight * matchWeight;
parent.softScores[scoreLevel] += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScores[scoreLevel] -= softImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight,
ConstraintMatchSupplier<BendableScore> constraintMatchSupplier) {
int hardImpact = scoreLevelWeight * matchWeight;
parent.hardScores[scoreLevel] += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScores[scoreLevel] -= hardImpact;
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, ConstraintMatchSupplier<BendableScore> constraintMatchSupplier) {
int[] hardImpacts = new int[hardScoreLevelCount];
int[] softImpacts = new int[softScoreLevelCount];
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
int hardImpact = constraintWeight.hardScore(hardScoreLevel) * matchWeight;
hardImpacts[hardScoreLevel] = hardImpact;
parent.hardScores[hardScoreLevel] += hardImpact;
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
int softImpact = constraintWeight.softScore(softScoreLevel) * matchWeight;
softImpacts[softScoreLevel] = softImpact;
parent.softScores[softScoreLevel] += softImpact;
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
parent.hardScores[hardScoreLevel] -= hardImpacts[hardScoreLevel];
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
parent.softScores[softScoreLevel] -= softImpacts[softScoreLevel];
}
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableScore.of(hardImpacts, softImpacts), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/BendableScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Arrays;
import java.util.Map;
import ai.timefold.solver.constraint.streams.common.AbstractConstraint;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class BendableScoreInliner extends AbstractScoreInliner<BendableScore> {
final int[] hardScores;
final int[] softScores;
BendableScoreInliner(Map<Constraint, BendableScore> constraintWeightMap, boolean constraintMatchEnabled, int hardLevelsSize,
int softLevelsSize) {
super(constraintWeightMap, constraintMatchEnabled);
hardScores = new int[hardLevelsSize];
softScores = new int[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableScore, ?> buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
Integer singleLevel = null;
BendableScore constraintWeight = constraintWeightMap.get(constraint);
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableScoreContext context = new BendableScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel));
if (isHardScore) {
return WeightedScoreImpacter.of(context, BendableScoreContext::changeHardScoreBy);
} else {
return WeightedScoreImpacter.of(context, BendableScoreContext::changeSoftScoreBy);
}
} else {
BendableScoreContext context = new BendableScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length);
return WeightedScoreImpacter.of(context, BendableScoreContext::changeScoreBy);
}
}
@Override
public BendableScore extractScore(int initScore) {
return BendableScore.ofUninitialized(initScore,
Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams/1.8.1/ai/timefold/solver/constraint/streams/common/inliner/BigDecimalWeightedScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
final class BigDecimalWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>>
implements WeightedScoreImpacter<Score_, Context_> {
private final BigDecimalImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public BigDecimalWeightedScoreImpacter(BigDecimalImpactFunction<Score_, Context_> impactFunction,
Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, BigDecimal.valueOf(matchWeight), constraintMatchSupplier);
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, BigDecimal.valueOf(matchWeight), constraintMatchSupplier);
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, matchWeight, constraintMatchSupplier);
}
@Override
public Context_ getContext() {
return context;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.