index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/Group3Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping0CollectorTriNode<OldA, OldB, OldC, A, B, C>
extends AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, TriTupleImpl<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.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
C c = groupKeyMappingC.apply(oldA, oldB, oldC);
return Triple.of(a, b, c);
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainer_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, QuadTupleImpl<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 QuadTupleImpl<A, B, C, D> createOutTuple(Triple<A, B, C> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, D d) {
outTuple.factD = d;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/Group4Mapping0CollectorTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.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>, QuadTupleImpl<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.getFactA();
OldB oldB = tuple.getFactB();
OldC oldC = tuple.getFactC();
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 Quadruple.of(a, b, c, d);
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), groupKey.getD(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.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.getFactA(), leftTuple.getFactB(), leftTuple.getFactC());
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/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.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractIndexedJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.TriPredicate;
final class IndexedJoinTriNode<A, B, C>
extends AbstractIndexedJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>, TriTupleImpl<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.getFactA(), leftTuple.getFactB());
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return new TriTupleImpl<>(leftTuple.getFactA(), leftTuple.getFactB(), rightTuple.getFactA(), outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(TriTupleImpl<A, B, C> outTuple, BiTuple<A, B> leftTuple) {
outTuple.factA = leftTuple.getFactA();
outTuple.factB = leftTuple.getFactB();
}
@Override
protected void setOutTupleRightFact(TriTupleImpl<A, B, C> outTuple, UniTuple<C> rightTuple) {
outTuple.factC = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/MapTriNode.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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.TriFunction;
final class MapTriNode<A, B, C, NewA> extends AbstractMapNode<TriTuple<A, B, C>, NewA> {
private final TriFunction<A, B, C, NewA> mappingFunction;
MapTriNode(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 NewA map(TriTuple<A, B, C> tuple) {
return mappingFunction.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/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.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
final class TriScorer<A, B, C> extends AbstractScorer<TriTuple<A, B, C>> {
private final TriFunction<A, B, C, UndoScoreImpacter> scoreImpacter;
public TriScorer(String constraintPackage, String constraintName, Score<?> constraintWeight,
TriFunction<A, B, C, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(constraintPackage, constraintName, constraintWeight, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(TriTuple<A, B, C> tuple) {
try {
return scoreImpacter.apply(tuple.getFactA(), tuple.getFactB(), tuple.getFactC());
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/TriTuple.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.Tuple;
public interface TriTuple<A, B, C> extends Tuple {
A getFactA();
B getFactB();
C getFactC();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/TriTupleImpl.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractTuple;
public final class TriTupleImpl<A, B, C> extends AbstractTuple implements TriTuple<A, B, C> {
// Only a tuple's origin node may modify a fact.
public A factA;
public B factB;
public C factC;
public TriTupleImpl(A factA, B factB, C factC, int storeSize) {
super(storeSize);
this.factA = factA;
this.factB = factB;
this.factC = factC;
}
@Override
public A getFactA() {
return factA;
}
@Override
public B getFactB() {
return factB;
}
@Override
public C getFactC() {
return factC;
}
@Override
public String toString() {
return "{" + factA + ", " + factB + ", " + factC + "}";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.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.getFactA(), leftTuple.getFactB(), leftTuple.getFactC(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/tri/UnindexedJoinTriNode.java | package ai.timefold.solver.constraint.streams.bavet.tri;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractUnindexedJoinNode;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.uni.UniTuple;
import ai.timefold.solver.core.api.function.TriPredicate;
final class UnindexedJoinTriNode<A, B, C>
extends AbstractUnindexedJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>, TriTupleImpl<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 TriTupleImpl<A, B, C> createOutTuple(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return new TriTupleImpl<>(leftTuple.getFactA(), leftTuple.getFactB(), rightTuple.getFactA(), outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(TriTupleImpl<A, B, C> outTuple, BiTuple<A, B> leftTuple) {
outTuple.factA = leftTuple.getFactA();
outTuple.factB = leftTuple.getFactB();
}
@Override
protected void setOutTupleRightFact(TriTupleImpl<A, B, C> outTuple, UniTuple<C> rightTuple) {
outTuple.factC = rightTuple.getFactA();
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.getFactA(), leftTuple.getFactB(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
abstract class AbstractGroupUniNode<OldA, OutTuple_ extends Tuple, MutableOutTuple_ extends OutTuple_, GroupKey_, ResultContainer_, Result_>
extends AbstractGroupNode<UniTuple<OldA>, OutTuple_, MutableOutTuple_, 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.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetAbstractUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor.of;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.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.BavetGroupBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetJoinBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetGroupQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetGroupTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
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;
public abstract class BavetAbstractUniConstraintStream<Solution_, A> extends BavetAbstractConstraintStream<Solution_>
implements InnerUniConstraintStream<A> {
protected final List<BavetAbstractUniConstraintStream<Solution_, A>> childStreamList = new ArrayList<>(2);
public BavetAbstractUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
}
public List<BavetAbstractUniConstraintStream<Solution_, A>> getChildStreamList() {
return childStreamList;
}
// ************************************************************************
// Stream builder methods
// ************************************************************************
public <Stream_ extends BavetAbstractUniConstraintStream<Solution_, A>> Stream_ shareAndAddChild(
Stream_ stream) {
return constraintFactory.share(stream, childStreamList::add);
}
// ************************************************************************
// 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) {
BavetAbstractUniConstraintStream<Solution_, B> other = assertBavetUniConstraintStream(otherStream);
BavetJoinBridgeUniConstraintStream<Solution_, A> leftBridge =
new BavetJoinBridgeUniConstraintStream<>(constraintFactory, this, true);
BavetJoinBridgeUniConstraintStream<Solution_, B> rightBridge =
new BavetJoinBridgeUniConstraintStream<>(constraintFactory, other, false);
BavetJoinBiConstraintStream<Solution_, A, B> joinStream =
new BavetJoinBiConstraintStream<>(constraintFactory, leftBridge, rightBridge,
joinerComber.getMergedJoiner(), joinerComber.getMergedFiltering());
leftBridge.setJoinStream(joinStream);
rightBridge.setJoinStream(joinStream);
return constraintFactory.share(joinStream, joinStream_ -> {
// Connect the bridges upstream, as it is an actual new join.
getChildStreamList().add(leftBridge);
other.getChildStreamList().add(rightBridge);
});
}
// ************************************************************************
// If (not) exists
// ************************************************************************
@SafeVarargs
@Override
public final <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> ifExistsIncludingNullVars(Class<B> otherClass, BiJoiner<A, B>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifExists(constraintFactory.forEachIncludingNullVars(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> ifNotExistsIncludingNullVars(Class<B> otherClass, BiJoiner<A, B>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return ifNotExists(constraintFactory.forEachIncludingNullVars(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) {
BavetAbstractUniConstraintStream<Solution_, B> other = assertBavetUniConstraintStream(otherStream);
BiJoinerComber<A, B> joinerComber = BiJoinerComber.comb(joiners);
BavetIfExistsBridgeUniConstraintStream<Solution_, B> parentBridgeB = other.shareAndAddChild(
new BavetIfExistsBridgeUniConstraintStream<>(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 = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group0Mapping1CollectorUniNode<>(groupStoreIndex, undoStoreIndex,
collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildUniGroupBy(nodeConstructor);
}
private <NewA> UniConstraintStream<NewA> buildUniGroupBy(GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
BavetUniGroupBridgeUniConstraintStream<Solution_, A, NewA> bridge = shareAndAddChild(
new BavetUniGroupBridgeUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupUniConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@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 = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group0Mapping2CollectorUniNode<>(groupStoreIndex, undoStoreIndex,
collectorA, collectorB, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
private <NewA, NewB> BiConstraintStream<NewA, NewB>
buildBiGroupBy(GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
BavetBiGroupBridgeUniConstraintStream<Solution_, A, NewA, NewB> bridge = shareAndAddChild(
new BavetBiGroupBridgeUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupBiConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_>
TriConstraintStream<ResultA_, ResultB_, ResultC_>
groupBy(UniConstraintCollector<A, ResultContainerA_, ResultA_> collectorA,
UniConstraintCollector<A, ResultContainerB_, ResultB_> collectorB,
UniConstraintCollector<A, ResultContainerC_, ResultC_> collectorC) {
GroupNodeConstructor<TriTuple<ResultA_, ResultB_, ResultC_>> nodeConstructor = of((groupStoreIndex, undoStoreIndex,
tupleLifecycle, outputStoreSize, environmentMode) -> new Group0Mapping3CollectorUniNode<>(groupStoreIndex,
undoStoreIndex, collectorA, collectorB, collectorC, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC> TriConstraintStream<NewA, NewB, NewC>
buildTriGroupBy(GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
BavetTriGroupBridgeUniConstraintStream<Solution_, A, NewA, NewB, NewC> bridge = shareAndAddChild(
new BavetTriGroupBridgeUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupTriConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <ResultContainerA_, ResultA_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<ResultA_, ResultB_, ResultC_, ResultD_>
groupBy(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 =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group0Mapping4CollectorUniNode<>(groupStoreIndex, undoStoreIndex, collectorA,
collectorB, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
private <NewA, NewB, NewC, NewD> QuadConstraintStream<NewA, NewB, NewC, NewD>
buildQuadGroupBy(GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
BavetQuadGroupBridgeUniConstraintStream<Solution_, A, NewA, NewB, NewC, NewD> bridge = shareAndAddChild(
new BavetQuadGroupBridgeUniConstraintStream<>(constraintFactory, this, nodeConstructor));
return constraintFactory.share(
new BavetGroupQuadConstraintStream<>(constraintFactory, bridge),
bridge::setGroupStream);
}
@Override
public <GroupKey_> UniConstraintStream<GroupKey_> groupBy(Function<A, GroupKey_> groupKeyMapping) {
GroupNodeConstructor<UniTuple<GroupKey_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group1Mapping0CollectorUniNode<>(
groupKeyMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
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 =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping2CollectorUniNode<>(groupKeyMapping, groupStoreIndex,
undoStoreIndex, collectorB, collectorC, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKey_, ResultContainerB_, ResultB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKey_, ResultB_, ResultC_, ResultD_>
groupBy(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 = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group1Mapping3CollectorUniNode<>(groupKeyMapping, groupStoreIndex, undoStoreIndex,
collectorB, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
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 = of((groupStoreIndex, undoStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode) -> new Group1Mapping1CollectorUniNode<>(groupKeyMapping, groupStoreIndex,
undoStoreIndex, collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildBiGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_> BiConstraintStream<GroupKeyA_, GroupKeyB_> groupBy(
Function<A, GroupKeyA_> groupKeyAMapping, Function<A, GroupKeyB_> groupKeyBMapping) {
GroupNodeConstructor<BiTuple<GroupKeyA_, GroupKeyB_>> nodeConstructor =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group2Mapping0CollectorUniNode<>(
groupKeyAMapping, groupKeyBMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
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 =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping1CollectorUniNode<>(groupKeyAMapping, groupKeyBMapping,
groupStoreIndex, undoStoreIndex, collector, tupleLifecycle, outputStoreSize, environmentMode));
return buildTriGroupBy(nodeConstructor);
}
@Override
public <GroupKeyA_, GroupKeyB_, ResultContainerC_, ResultC_, ResultContainerD_, ResultD_>
QuadConstraintStream<GroupKeyA_, GroupKeyB_, ResultC_, ResultD_> groupBy(
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 = of((groupStoreIndex,
undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group2Mapping2CollectorUniNode<>(groupKeyAMapping, groupKeyBMapping, groupStoreIndex,
undoStoreIndex, collectorC, collectorD, tupleLifecycle, outputStoreSize, environmentMode));
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 = of((groupStoreIndex,
tupleLifecycle, outputStoreSize, environmentMode) -> new Group3Mapping0CollectorUniNode<>(groupKeyAMapping,
groupKeyBMapping, groupKeyCMapping, groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode));
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 =
of((groupStoreIndex, undoStoreIndex, tupleLifecycle, outputStoreSize,
environmentMode) -> new Group3Mapping1CollectorUniNode<>(groupKeyAMapping, groupKeyBMapping,
groupKeyCMapping, groupStoreIndex, undoStoreIndex, collectorD, tupleLifecycle, outputStoreSize,
environmentMode));
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 =
of((groupStoreIndex, tupleLifecycle, outputStoreSize, environmentMode) -> new Group4Mapping0CollectorUniNode<>(
groupKeyAMapping, groupKeyBMapping, groupKeyCMapping, groupKeyDMapping, groupStoreIndex, tupleLifecycle,
outputStoreSize, environmentMode));
return buildQuadGroupBy(nodeConstructor);
}
// ************************************************************************
// Operations with duplicate tuple possibility
// ************************************************************************
@Override
public <ResultA_> UniConstraintStream<ResultA_> map(Function<A, ResultA_> mapping) {
BavetMapBridgeUniConstraintStream<Solution_, A, ResultA_> bridge = shareAndAddChild(
new BavetMapBridgeUniConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetMapUniConstraintStream<>(constraintFactory, bridge),
bridge::setMapStream);
}
@Override
public <ResultA_> UniConstraintStream<ResultA_> flattenLast(Function<A, Iterable<ResultA_>> mapping) {
BavetFlattenLastBridgeUniConstraintStream<Solution_, A, ResultA_> bridge = shareAndAddChild(
new BavetFlattenLastBridgeUniConstraintStream<>(constraintFactory, this, mapping));
return constraintFactory.share(
new BavetFlattenLastUniConstraintStream<>(constraintFactory, bridge),
bridge::setFlattenLastStream);
}
// ************************************************************************
// 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-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetBiGroupBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.bi.BavetGroupBiConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetBiGroupBridgeUniConstraintStream<Solution_, A, NewA, NewB>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream;
private final GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor;
public BavetBiGroupBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<BiTuple<NewA, NewB>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupBiConstraintStream<Solution_, NewA, NewB> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetFilterUniConstraintStream.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.core.api.score.Score;
public final class BavetFilterUniConstraintStream<Solution_, A> extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final Predicate<A> predicate;
public BavetFilterUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Predicate<A> predicate) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.predicate = predicate;
if (predicate == null) {
throw new IllegalArgumentException("The predicate (null) cannot be null.");
}
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
buildHelper.<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) {
BavetFilterUniConstraintStream<?, ?> other = (BavetFilterUniConstraintStream<?, ?>) o;
return parent == other.parent
&& predicate == other.predicate;
} else {
return false;
}
}
@Override
public String toString() {
return "Filter() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetFlattenLastBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetFlattenLastBridgeUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final Function<A, Iterable<NewA>> mappingFunction;
private BavetFlattenLastUniConstraintStream<Solution_, NewA> flattenLastStream;
public BavetFlattenLastBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
Function<A, Iterable<NewA>> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setFlattenLastStream(BavetFlattenLastUniConstraintStream<Solution_, NewA> flattenLastStream) {
this.flattenLastStream = flattenLastStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has an non-empty childStreamList (" + childStreamList + ") but it's a flattenLast bridge.");
}
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(flattenLastStream);
AbstractFlattenLastNode<UniTuple<A>, UniTuple<NewA>, A, NewA> node = new FlattenLastUniNode<>(
inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(flattenLastStream.getChildStreamList()),
outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetFlattenLastUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetFlattenLastUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetFlattenLastUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetFlattenLastBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "FlattenLast() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetForEachUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
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> {
private final Class<A> forEachClass;
public BavetForEachUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory, Class<A> forEachClass,
RetrievalSemantics retrievalSemantics) {
super(constraintFactory, retrievalSemantics);
this.forEachClass = forEachClass;
if (forEachClass == null) {
throw new IllegalArgumentException("The forEachClass (null) cannot be null.");
}
}
@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);
buildHelper.addNode(new ForEachUniNode<>(forEachClass, tupleLifecycle, outputStoreSize));
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public int hashCode() {
return forEachClass.hashCode();
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
} else if (o instanceof BavetForEachUniConstraintStream) {
BavetForEachUniConstraintStream<?, ?> other = (BavetForEachUniConstraintStream<?, ?>) o;
return forEachClass.equals(other.forEachClass);
} else {
return false;
}
}
@Override
public String toString() {
return "ForEach(" + forEachClass.getSimpleName() + ") with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
public Class<A> getForEachClass() {
return forEachClass;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetGroupUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetGroupUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetGroupUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetGroupBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "Group() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetIfExistsBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetIfExistsBridgeUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
public BavetIfExistsBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetIfExistsUniConstraintStream builds everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
@Override
public String toString() {
return "IfExistsBridge()";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetIfExistsUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
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.AbstractIfExistsNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexerFactory;
import ai.timefold.solver.constraint.streams.bavet.common.index.JoinerUtils;
import ai.timefold.solver.constraint.streams.common.bi.DefaultBiJoiner;
import ai.timefold.solver.core.api.score.Score;
public final class BavetIfExistsUniConstraintStream<Solution_, A, B> extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parentA;
private final BavetIfExistsBridgeUniConstraintStream<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,
BavetIfExistsBridgeUniConstraintStream<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 indexerFactory = new IndexerFactory(joiner);
AbstractIfExistsNode<UniTuple<A>, B> node = indexerFactory.hasJoiners()
? (filtering == null ? new IndexedIfExistsUniNode<>(shouldExist,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
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,
JoinerUtils.combineLeftMappings(joiner), JoinerUtils.combineRightMappings(joiner),
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, parentBridgeB);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "IfExists() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetJoinBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetJoinConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetJoinBridgeUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final boolean isLeftBridge;
private BavetJoinConstraintStream<Solution_> joinStream;
public BavetJoinBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, boolean isLeftBridge) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.isLeftBridge = isLeftBridge;
}
public void setJoinStream(BavetJoinConstraintStream<Solution_> joinStream) {
this.joinStream = joinStream;
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
public BavetAbstractUniConstraintStream<Solution_, A> getParent() {
return parent;
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetJoinBiConstraintStream, BavetJoinTriConstraintStream, etc build everything.
}
@Override
public String toString() {
return "JoinBridge()";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetMapBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractMapNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetMapBridgeUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final Function<A, NewA> mappingFunction;
private BavetMapUniConstraintStream<Solution_, NewA> mapStream;
public BavetMapBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, Function<A, NewA> mappingFunction) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.mappingFunction = mappingFunction;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
public void setMapStream(BavetMapUniConstraintStream<Solution_, NewA> mapStream) {
this.mapStream = mapStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has a non-empty childStreamList (" + childStreamList + ") but it's a flattenLast bridge.");
}
int inputStoreIndex = buildHelper.reserveTupleStoreIndex(parent.getTupleSource());
int outputStoreSize = buildHelper.extractTupleStoreSize(mapStream);
AbstractMapNode<UniTuple<A>, NewA> node = new MapUniNode<>(inputStoreIndex, mappingFunction,
buildHelper.getAggregatedTupleLifecycle(mapStream.getChildStreamList()), outputStoreSize);
buildHelper.addNode(node, this);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetMapUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
public final class BavetMapUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractConstraintStream<Solution_> parent;
public BavetMapUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractConstraintStream<Solution_> parent) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
}
@Override
public boolean guaranteesDistinct() {
return false;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
// Do nothing. BavetMapBridgeUniConstraintStream, etc build everything.
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// TODO
@Override
public String toString() {
return "Map() with " + childStreamList.size() + " children";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetQuadGroupBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.quad.BavetGroupQuadConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetQuadGroupBridgeUniConstraintStream<Solution_, A, NewA, NewB, NewC, NewD>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private BavetGroupQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> groupStream;
private final GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor;
public BavetQuadGroupBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<QuadTuple<NewA, NewB, NewC, NewD>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupQuadConstraintStream<Solution_, NewA, NewB, NewC, NewD> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetScoringUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import static ai.timefold.solver.constraint.streams.common.inliner.JustificationsSupplier.of;
import java.math.BigDecimal;
import java.util.Set;
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.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.BavetScoringConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.common.inliner.JustificationsSupplier;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.constraint.streams.common.inliner.WeightedScoreImpacter;
import ai.timefold.solver.core.api.score.Score;
public final class BavetScoringUniConstraintStream<Solution_, A>
extends BavetAbstractUniConstraintStream<Solution_, A>
implements BavetScoringConstraintStream<Solution_> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private final boolean noMatchWeigher;
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, false, 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, false, 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, false, null, null, bigDecimalMatchWeigher);
if (bigDecimalMatchWeigher == null) {
throw new IllegalArgumentException("The matchWeigher (null) cannot be null.");
}
}
private BavetScoringUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
boolean noMatchWeigher, ToIntFunction<A> intMatchWeigher, ToLongFunction<A> longMatchWeigher,
Function<A, BigDecimal> bigDecimalMatchWeigher) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.noMatchWeigher = noMatchWeigher;
this.intMatchWeigher = intMatchWeigher;
this.longMatchWeigher = longMatchWeigher;
this.bigDecimalMatchWeigher = bigDecimalMatchWeigher;
}
@Override
public void setConstraint(BavetConstraint<Solution_> constraint) {
this.constraint = constraint;
}
@Override
public boolean guaranteesDistinct() {
return parent.guaranteesDistinct();
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
if (!childStreamList.isEmpty()) {
throw new IllegalStateException("Impossible state: the stream (" + this
+ ") has an non-empty childStreamList (" + childStreamList + ") but it's an endpoint.");
}
Score_ constraintWeight = buildHelper.getConstraintWeight(constraint);
WeightedScoreImpacter<Score_, ?> weightedScoreImpacter =
buildHelper.getScoreInliner().buildWeightedScoreImpacter(constraint, constraintWeight);
boolean constraintMatchEnabled = buildHelper.getScoreInliner().isConstraintMatchEnabled();
Function<A, UndoScoreImpacter> scoreImpacter;
if (intMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = a -> {
int matchWeight = intMatchWeigher.applyAsInt(a);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (longMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = a -> {
long matchWeight = longMatchWeigher.applyAsLong(a);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (bigDecimalMatchWeigher != null) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
constraint.assertCorrectImpact(matchWeight);
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(matchWeight, justificationsSupplier);
};
} else {
scoreImpacter = a -> {
BigDecimal matchWeight = bigDecimalMatchWeigher.apply(a);
constraint.assertCorrectImpact(matchWeight);
return weightedScoreImpacter.impactScore(matchWeight, null);
};
}
} else if (noMatchWeigher) {
if (constraintMatchEnabled) {
scoreImpacter = a -> {
JustificationsSupplier justificationsSupplier =
of(constraint, constraint.getJustificationMapping(), constraint.getIndictedObjectsMapping(), a);
return weightedScoreImpacter.impactScore(1, justificationsSupplier);
};
} else {
scoreImpacter = a -> weightedScoreImpacter.impactScore(1, null);
}
} else {
throw new IllegalStateException("Impossible state: neither of the supported match weighers provided.");
}
UniScorer<A> scorer = new UniScorer<>(constraint.getConstraintPackage(), constraint.getConstraintName(),
constraintWeight, scoreImpacter, buildHelper.reserveTupleStoreIndex(parent.getTupleSource()));
buildHelper.putInsertUpdateRetract(this, scorer);
}
// ************************************************************************
// Equality for node sharing
// ************************************************************************
// No node sharing
@Override
public String toString() {
return "Scoring(" + constraint.getConstraintName() + ")";
}
// ************************************************************************
// Getters/setters
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetTriGroupBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.constraint.streams.bavet.tri.BavetGroupTriConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetTriGroupBridgeUniConstraintStream<Solution_, A, NewA, NewB, NewC>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream;
private final GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor;
public BavetTriGroupBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent,
GroupNodeConstructor<TriTuple<NewA, NewB, NewC>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupTriConstraintStream<Solution_, NewA, NewB, NewC> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/BavetUniGroupBridgeUniConstraintStream.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.List;
import java.util.Set;
import ai.timefold.solver.constraint.streams.bavet.BavetConstraintFactory;
import ai.timefold.solver.constraint.streams.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.constraint.streams.bavet.common.GroupNodeConstructor;
import ai.timefold.solver.constraint.streams.bavet.common.NodeBuildHelper;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
final class BavetUniGroupBridgeUniConstraintStream<Solution_, A, NewA>
extends BavetAbstractUniConstraintStream<Solution_, A> {
private final BavetAbstractUniConstraintStream<Solution_, A> parent;
private BavetGroupUniConstraintStream<Solution_, NewA> groupStream;
private final GroupNodeConstructor<UniTuple<NewA>> nodeConstructor;
public BavetUniGroupBridgeUniConstraintStream(BavetConstraintFactory<Solution_> constraintFactory,
BavetAbstractUniConstraintStream<Solution_, A> parent, GroupNodeConstructor<UniTuple<NewA>> nodeConstructor) {
super(constraintFactory, parent.getRetrievalSemantics());
this.parent = parent;
this.nodeConstructor = nodeConstructor;
}
@Override
public boolean guaranteesDistinct() {
return true;
}
public void setGroupStream(BavetGroupUniConstraintStream<Solution_, NewA> groupStream) {
this.groupStream = groupStream;
}
// ************************************************************************
// Node creation
// ************************************************************************
@Override
public void collectActiveConstraintStreams(Set<BavetAbstractConstraintStream<Solution_>> constraintStreamSet) {
parent.collectActiveConstraintStreams(constraintStreamSet);
constraintStreamSet.add(this);
}
@Override
public <Score_ extends Score<Score_>> void buildNode(NodeBuildHelper<Score_> buildHelper) {
List<? extends ConstraintStream> groupStreamChildList = groupStream.getChildStreamList();
nodeConstructor.build(buildHelper, parent.getTupleSource(), groupStream, groupStreamChildList, this, childStreamList,
constraintFactory.getEnvironmentMode());
}
@Override
public BavetAbstractConstraintStream<Solution_> getTupleSource() {
return parent.getTupleSource();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/ConditionalUniTupleLifecycle.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Predicate;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractConditionalTupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
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.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
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 UniTupleImpl<>(item, outputStoreSize);
}
@Override
protected A getEffectiveFactIn(UniTuple<A> tuple) {
return tuple.getFactA();
}
@Override
protected NewA getEffectiveFactOut(UniTuple<NewA> outTuple) {
return outTuple.getFactA();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/ForEachUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.ArrayDeque;
import java.util.IdentityHashMap;
import java.util.Map;
import java.util.Queue;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractNode;
import ai.timefold.solver.constraint.streams.bavet.common.BavetTupleState;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
public final class ForEachUniNode<A> extends AbstractNode {
private final Class<A> forEachClass;
/**
* Calls for example {@link UniScorer#insert(UniTuple)}, and/or ...
*/
private final TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle;
private final int outputStoreSize;
private final Map<A, UniTupleImpl<A>> tupleMap = new IdentityHashMap<>(1000);
private final Queue<UniTupleImpl<A>> dirtyTupleQueue;
public ForEachUniNode(Class<A> forEachClass, TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize) {
this.forEachClass = forEachClass;
this.nextNodesTupleLifecycle = nextNodesTupleLifecycle;
this.outputStoreSize = outputStoreSize;
dirtyTupleQueue = new ArrayDeque<>(1000);
}
public void insert(A a) {
UniTupleImpl<A> tuple = new UniTupleImpl<>(a, outputStoreSize);
UniTupleImpl<A> old = tupleMap.put(a, tuple);
if (old != null) {
throw new IllegalStateException("The fact (" + a + ") was already inserted, so it cannot insert again.");
}
dirtyTupleQueue.add(tuple);
}
public void update(A a) {
UniTupleImpl<A> tuple = tupleMap.get(a);
if (tuple == null) {
throw new IllegalStateException("The fact (" + a + ") was never inserted, so it cannot update.");
}
if (tuple.state.isDirty()) {
if (tuple.state == BavetTupleState.DYING || tuple.state == BavetTupleState.ABORTING) {
throw new IllegalStateException("The fact (" + a + ") was retracted, so it cannot update.");
}
} else {
tuple.state = BavetTupleState.UPDATING;
dirtyTupleQueue.add(tuple);
}
}
public void retract(A a) {
UniTupleImpl<A> tuple = tupleMap.remove(a);
if (tuple == null) {
throw new IllegalStateException("The fact (" + a + ") was never inserted, so it cannot retract.");
}
if (tuple.state.isDirty()) {
if (tuple.state == BavetTupleState.DYING || tuple.state == BavetTupleState.ABORTING) {
throw new IllegalStateException("The fact (" + a + ") was already retracted, so it cannot retract.");
}
tuple.state = BavetTupleState.ABORTING;
} else {
tuple.state = BavetTupleState.DYING;
dirtyTupleQueue.add(tuple);
}
}
@Override
public void calculateScore() {
for (UniTupleImpl<A> tuple : dirtyTupleQueue) {
switch (tuple.state) {
case CREATING:
nextNodesTupleLifecycle.insert(tuple);
tuple.state = BavetTupleState.OK;
break;
case UPDATING:
nextNodesTupleLifecycle.update(tuple);
tuple.state = BavetTupleState.OK;
break;
case DYING:
nextNodesTupleLifecycle.retract(tuple);
tuple.state = BavetTupleState.DEAD;
break;
case ABORTING:
tuple.state = BavetTupleState.DEAD;
break;
case OK:
case DEAD:
default:
throw new IllegalStateException("Impossible state: The tuple (" + tuple + ") in node (" +
this + ") is in an unexpected state (" + tuple.state + ").");
}
}
dirtyTupleQueue.clear();
}
@Override
public String toString() {
return super.toString() + "(" + forEachClass.getSimpleName() + ")";
}
public Class<A> getForEachClass() {
return forEachClass;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group0Mapping1CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
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>, UniTupleImpl<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 UniTupleImpl<A> createOutTuple(Void groupKey) {
return new UniTupleImpl<>(null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTupleImpl<A> outTuple, A a) {
outTuple.factA = a;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group0Mapping2CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.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>, BiTupleImpl<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::of);
}
@Override
protected BiTupleImpl<A, B> createOutTuple(Void groupKey) {
return new BiTupleImpl<>(null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, Pair<A, B> result) {
outTuple.factA = result.getKey();
outTuple.factB = result.getValue();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group0Mapping3CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.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>, TriTupleImpl<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::of);
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Void groupKey) {
return new TriTupleImpl<>(null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Triple<A, B, C> result) {
outTuple.factA = result.getA();
outTuple.factB = result.getB();
outTuple.factC = result.getC();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group0Mapping4CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.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>, QuadTupleImpl<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::of);
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Void groupKey) {
return new QuadTupleImpl<>(null, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Quadruple<A, B, C, D> result) {
outTuple.factA = result.getA();
outTuple.factB = result.getB();
outTuple.factC = result.getC();
outTuple.factD = result.getD();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group1Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping0CollectorUniNode<OldA, A>
extends AbstractGroupUniNode<OldA, UniTuple<A>, UniTupleImpl<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.getFactA());
}
@Override
protected UniTupleImpl<A> createOutTuple(A a) {
return new UniTupleImpl<>(a, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTupleImpl<A> aUniTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
final class Group1Mapping1CollectorUniNode<OldA, A, B, ResultContainer_>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, BiTupleImpl<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 BiTupleImpl<A, B> createOutTuple(A a) {
return new BiTupleImpl<>(a, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, B b) {
outTuple.factB = b;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.api.score.stream.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>, TriTupleImpl<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 TriTupleImpl<A, B, C> createOutTuple(A a) {
return new TriTupleImpl<>(a, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Pair<B, C> result) {
outTuple.factB = result.getKey();
outTuple.factC = result.getValue();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.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>, QuadTupleImpl<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 QuadTupleImpl<A, B, C, D> createOutTuple(A a) {
return new QuadTupleImpl<>(a, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Triple<B, C, D> result) {
outTuple.factB = result.getA();
outTuple.factC = result.getB();
outTuple.factD = result.getC();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group2Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTuple;
import ai.timefold.solver.constraint.streams.bavet.bi.BiTupleImpl;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Pair;
final class Group2Mapping0CollectorUniNode<OldA, A, B>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, BiTupleImpl<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.getFactA();
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
return Pair.of(a, b);
}
@Override
protected BiTupleImpl<A, B> createOutTuple(Pair<A, B> groupKey) {
return new BiTupleImpl<>(groupKey.getKey(), groupKey.getValue(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTupleImpl<A, B> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.api.score.stream.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>, TriTupleImpl<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 TriTupleImpl<A, B, C> createOutTuple(Pair<A, B> groupKey) {
return new TriTupleImpl<>(groupKey.getKey(), groupKey.getValue(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, C c) {
outTuple.factC = c;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.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>, QuadTupleImpl<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 QuadTupleImpl<A, B, C, D> createOutTuple(Pair<A, B> groupKey) {
return new QuadTupleImpl<>(groupKey.getKey(), groupKey.getValue(), null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Pair<C, D> result) {
outTuple.factC = result.getKey();
outTuple.factD = result.getValue();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group3Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTuple;
import ai.timefold.solver.constraint.streams.bavet.tri.TriTupleImpl;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Triple;
final class Group3Mapping0CollectorUniNode<OldA, A, B, C>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, TriTupleImpl<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.getFactA();
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
C c = groupKeyMappingC.apply(oldA);
return Triple.of(a, b, c);
}
@Override
protected TriTupleImpl<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTupleImpl<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.api.score.stream.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>, QuadTupleImpl<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 QuadTupleImpl<A, B, C, D> createOutTuple(Triple<A, B, C> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, D d) {
outTuple.factD = d;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/Group4Mapping0CollectorUniNode.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTuple;
import ai.timefold.solver.constraint.streams.bavet.quad.QuadTupleImpl;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.util.Quadruple;
final class Group4Mapping0CollectorUniNode<OldA, A, B, C, D>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, QuadTupleImpl<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.getFactA();
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
C c = groupKeyMappingC.apply(oldA);
D d = groupKeyMappingD.apply(oldA);
return Quadruple.of(a, b, c, d);
}
@Override
protected QuadTupleImpl<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTupleImpl<>(groupKey.getA(), groupKey.getB(), groupKey.getC(), groupKey.getD(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTupleImpl<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
import ai.timefold.solver.constraint.streams.bavet.common.index.IndexProperties;
import ai.timefold.solver.constraint.streams.bavet.common.index.Indexer;
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.getFactA());
}
@Override
protected boolean testFiltering(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return filtering.test(leftTuple.getFactA(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/MapUniNode.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.TupleLifecycle;
final class MapUniNode<A, NewA> extends AbstractMapNode<UniTuple<A>, NewA> {
private final Function<A, NewA> mappingFunction;
MapUniNode(int mapStoreIndex, Function<A, NewA> mappingFunction, TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle,
int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
protected NewA map(UniTuple<A> tuple) {
return mappingFunction.apply(tuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/UniScorer.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractScorer;
import ai.timefold.solver.constraint.streams.common.inliner.UndoScoreImpacter;
import ai.timefold.solver.core.api.score.Score;
final class UniScorer<A> extends AbstractScorer<UniTuple<A>> {
private final Function<A, UndoScoreImpacter> scoreImpacter;
public UniScorer(String constraintPackage, String constraintName, Score<?> constraintWeight,
Function<A, UndoScoreImpacter> scoreImpacter, int inputStoreIndex) {
super(constraintPackage, constraintName, constraintWeight, inputStoreIndex);
this.scoreImpacter = scoreImpacter;
}
@Override
protected UndoScoreImpacter impact(UniTuple<A> tuple) {
try {
return scoreImpacter.apply(tuple.getFactA());
} catch (Exception e) {
throw createExceptionOnImpact(tuple, e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/UniTuple.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.common.Tuple;
public interface UniTuple<A> extends Tuple {
A getFactA();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/uni/UniTupleImpl.java | package ai.timefold.solver.constraint.streams.bavet.uni;
import ai.timefold.solver.constraint.streams.bavet.common.AbstractTuple;
public final class UniTupleImpl<A> extends AbstractTuple implements UniTuple<A> {
// Only a tuple's origin node may modify a fact.
public A factA;
public UniTupleImpl(A factA, int storeSize) {
super(storeSize);
this.factA = factA;
}
@Override
public A getFactA() {
return factA;
}
@Override
public String toString() {
return "{" + factA + "}";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-bavet/0.9.39/ai/timefold/solver/constraint/streams/bavet/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.TupleLifecycle;
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.getFactA(), rightTuple.getFactA());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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.ConstraintMatchTotal;
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 String constraintPackage;
private final String constraintName;
private final String constraintId;
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, String constraintPackage, String constraintName,
Function<Solution_, Score<?>> constraintWeightExtractor, ScoreImpactType scoreImpactType,
boolean isConstraintWeightConfigurable, Object justificationMapping, Object indictedObjectsMapping) {
this.constraintFactory = constraintFactory;
this.constraintPackage = constraintPackage;
this.constraintName = constraintName;
this.constraintId = ConstraintMatchTotal.composeConstraintId(constraintPackage, constraintName);
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();
}
Score_ constraintWeight = (Score_) constraintWeightExtractor.apply(workingSolution);
constraintFactory.getSolutionDescriptor().validateConstraintWeight(constraintPackage, constraintName, constraintWeight);
switch (scoreImpactType) {
case PENALTY:
return constraintWeight.negate();
case REWARD:
case MIXED:
return constraintWeight;
default:
throw new IllegalStateException("Unknown score impact type: (" + scoreImpactType + ")");
}
}
public final void assertCorrectImpact(int impact) {
if (scoreImpactType == ScoreImpactType.MIXED) { // No need to do anything.
return;
}
if (impact < 0) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ getConstraintId() + "). " +
"Check constraint provider implementation.");
}
}
public final void assertCorrectImpact(long impact) {
if (scoreImpactType == ScoreImpactType.MIXED) { // No need to do anything.
return;
}
if (impact < 0L) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ getConstraintId() + "). " +
"Check constraint provider implementation.");
}
}
public final void assertCorrectImpact(BigDecimal impact) {
if (scoreImpactType == ScoreImpactType.MIXED) { // No need to do anything.
return;
}
if (impact.signum() < 0) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ getConstraintId() + "). " +
"Check constraint provider implementation.");
}
}
@Override
public final ConstraintFactory_ getConstraintFactory() {
return constraintFactory;
}
@Override
public final String getConstraintPackage() {
return constraintPackage;
}
@Override
public final String getConstraintName() {
return constraintName;
}
@Override
public final String getConstraintId() { // Overridden in order to cache the string concatenation.
return constraintId;
}
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-common/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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.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(String constraintPackage, String constraintName) {
validateConstraintId(constraintPackage, constraintName);
SolutionDescriptor<Solution_> solutionDescriptor = getConstraintFactory().getSolutionDescriptor();
ConstraintConfigurationDescriptor<Solution_> configurationDescriptor = solutionDescriptor
.getConstraintConfigurationDescriptor();
if (configurationDescriptor == null) {
throw new IllegalStateException("The constraint (" + constraintName + ") of package (" + constraintPackage
+ ") 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(constraintPackage, constraintName);
if (weightDescriptor == null) {
throw new IllegalStateException("The constraint (" + constraintName + ") of package (" + constraintPackage
+ ") 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(String constraintPackage, String constraintName,
Score<?> constraintWeight) {
validateConstraintId(constraintPackage, constraintName);
// Duplicates validation when the session is built, but this fails fast when weights are hard coded
getConstraintFactory().getSolutionDescriptor().validateConstraintWeight(constraintPackage, constraintName,
constraintWeight);
return solution -> constraintWeight;
}
private static void validateConstraintId(String constraintPackage, String constraintName) {
if (constraintPackage == null) {
throw new IllegalStateException("The constraint (" + constraintName
+ ") cannot have a null package (" + constraintPackage + ").");
}
if (constraintName == null) {
throw new IllegalStateException("The constraint of package (" + constraintPackage
+ ") cannot have a null name (" + constraintName + ").");
}
}
// ************************************************************************
// 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-common/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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.api.score.stream.ConstraintStreamImplType;
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 boolean supportsImplType(ConstraintStreamImplType constraintStreamImplType);
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-common/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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.function.Predicate;
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.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.api.score.stream.uni.UniConstraintStream;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
public abstract class InnerConstraintFactory<Solution_, Constraint_ extends Constraint> implements ConstraintFactory {
@Override
public <A> UniConstraintStream<A> forEach(Class<A> sourceClass) {
UniConstraintStream<A> stream = forEachIncludingNullVars(sourceClass);
Predicate<A> nullityFilter = getNullityFilter(sourceClass);
return nullityFilter == null ? stream : stream.filter(nullityFilter);
}
public <A> Predicate<A> getNullityFilter(Class<A> fromClass) {
EntityDescriptor<Solution_> entityDescriptor = getSolutionDescriptor().findEntityDescriptor(fromClass);
if (entityDescriptor != null && entityDescriptor.hasAnyGenuineVariables()) {
return (Predicate<A>) entityDescriptor.getHasNoNullVariables();
}
return null;
}
@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 =
ConfigUtils.findPlanningIdMemberAccessor(sourceClass, solutionDescriptor.getMemberAccessorFactory(),
solutionDescriptor.getDomainAccessType());
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> UniConstraintStream<A> from(Class<A> fromClass) {
UniConstraintStream<A> stream = fromUnfiltered(fromClass);
EntityDescriptor<Solution_> entityDescriptor = getSolutionDescriptor().findEntityDescriptor(fromClass);
if (entityDescriptor != null && entityDescriptor.hasAnyGenuineVariables()) {
Predicate<A> predicate = (Predicate<A>) entityDescriptor.getIsInitializedPredicate();
stream = stream.filter(predicate);
}
return stream;
}
@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<String, List<Constraint>> constraintsPerIdMap =
Arrays.stream(constraints).collect(groupingBy(Constraint::getConstraintId));
constraintsPerIdMap.forEach((constraintId, duplicateConstraintList) -> {
if (duplicateConstraintList.size() > 1) {
throw new IllegalStateException("There are multiple constraints with the same ID (" + constraintId + ").");
}
});
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-common/0.9.39/ai/timefold/solver/constraint/streams | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/RetrievalSemantics.java | package ai.timefold.solver.constraint.streams.common;
/**
* Determines the behavior of joins and conditional propagation
* based on whether they are coming off of a constraint stream started by
* either {@link ai.timefold.solver.core.api.score.stream.ConstraintFactory#from(Class)}
* or {@link ai.timefold.solver.core.api.score.stream.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 nullable planning variables.
* (See {@link ai.timefold.solver.core.api.domain.variable.PlanningVariable}.)
*/
public enum RetrievalSemantics {
/**
* Joins do not include entities with null planning variables,
* unless specifically requested by join(forEachIncludingNullVars(...)).
* Conditional propagation does not include null planning variables,
* unless specifically requested using a *IncludingNullVars() method overload.
*
* <p>
* Applies when the stream comes off of a {@link ai.timefold.solver.core.api.score.stream.ConstraintFactory#forEach(Class)}
* family of methods.
*/
STANDARD,
/**
* Joins include entities with null planning variables if these variables are nullable.
* Conditional propagation always includes entities with null planning variables,
* regardless of whether their planning variables are nullable.
*
* <p>
* Applies when the stream comes off of a {@link ai.timefold.solver.core.api.score.stream.ConstraintFactory#from(Class)}
* family of methods.
*
* @deprecated this semantics is deprecated and kept around for backward compatibility reasons. It will be removed in 9.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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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 (" + 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 (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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 (this == o) {
return true;
}
if (!(o instanceof DefaultBiJoiner)) {
return false;
}
DefaultBiJoiner<?, ?> other = (DefaultBiJoiner<?, ?>) o;
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
@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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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.Collection;
import java.util.List;
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 List::of;
}
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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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.List;
import java.util.Map;
import java.util.stream.Collectors;
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;
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, boolean constraintMatchEnabled) {
if (scoreDefinition instanceof SimpleScoreDefinition) {
return (ScoreInliner_) new SimpleScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof SimpleLongScoreDefinition) {
return (ScoreInliner_) new SimpleLongScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof SimpleBigDecimalScoreDefinition) {
return (ScoreInliner_) new SimpleBigDecimalScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof HardSoftScoreDefinition) {
return (ScoreInliner_) new HardSoftScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof HardSoftLongScoreDefinition) {
return (ScoreInliner_) new HardSoftLongScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof HardSoftBigDecimalScoreDefinition) {
return (ScoreInliner_) new HardSoftBigDecimalScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof HardMediumSoftScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof HardMediumSoftLongScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftLongScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof HardMediumSoftBigDecimalScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftBigDecimalScoreInliner(constraintMatchEnabled);
} else if (scoreDefinition instanceof BendableScoreDefinition) {
BendableScoreDefinition bendableScoreDefinition = (BendableScoreDefinition) scoreDefinition;
return (ScoreInliner_) new BendableScoreInliner(constraintMatchEnabled, bendableScoreDefinition.getHardLevelsSize(),
bendableScoreDefinition.getSoftLevelsSize());
} else if (scoreDefinition instanceof BendableLongScoreDefinition) {
BendableLongScoreDefinition bendableScoreDefinition = (BendableLongScoreDefinition) scoreDefinition;
return (ScoreInliner_) new BendableLongScoreInliner(constraintMatchEnabled,
bendableScoreDefinition.getHardLevelsSize(),
bendableScoreDefinition.getSoftLevelsSize());
} else if (scoreDefinition instanceof BendableBigDecimalScoreDefinition) {
BendableBigDecimalScoreDefinition bendableScoreDefinition = (BendableBigDecimalScoreDefinition) scoreDefinition;
return (ScoreInliner_) new BendableBigDecimalScoreInliner(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 9.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 9.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 9.0.", cause);
}
}
}
protected final boolean constraintMatchEnabled;
private final Map<String, DefaultConstraintMatchTotal<Score_>> constraintMatchTotalMap;
private final Map<Object, DefaultIndictment<Score_>> indictmentMap;
protected AbstractScoreInliner(boolean constraintMatchEnabled) {
this.constraintMatchEnabled = constraintMatchEnabled;
this.constraintMatchTotalMap = constraintMatchEnabled ? new LinkedHashMap<>() : null;
this.indictmentMap = constraintMatchEnabled ? new LinkedHashMap<>() : null;
}
public abstract Score_ extractScore(int initScore);
/**
* Create a new instance of {@link WeightedScoreImpacter} for a particular constraint.
*
* @param constraint never null
* @param constraintWeight never null
* @return never null
*/
public abstract WeightedScoreImpacter<Score_, ?> buildWeightedScoreImpacter(Constraint constraint, Score_ constraintWeight);
protected final Runnable addConstraintMatch(Constraint constraint, Score_ constraintWeight, Score_ score,
JustificationsSupplier justificationsSupplier) {
String constraintPackage = constraint.getConstraintPackage();
String constraintName = constraint.getConstraintName();
DefaultConstraintMatchTotal<Score_> constraintMatchTotal = constraintMatchTotalMap.computeIfAbsent(
constraint.getConstraintId(),
key -> new DefaultConstraintMatchTotal<>(constraintPackage, constraintName, constraintWeight));
ConstraintMatch<Score_> constraintMatch = constraintMatchTotal.addConstraintMatch(
justificationsSupplier.createConstraintJustification(score),
justificationsSupplier.createIndictedObjects(), score);
List<DefaultIndictment<Score_>> indictments = constraintMatch.getIndictedObjectList()
.stream()
.distinct() // One match might have the same justification twice
.map(justificationPart -> processJustification(constraintMatch, justificationPart))
.collect(Collectors.toList());
return () -> {
constraintMatchTotal.removeConstraintMatch(constraintMatch);
if (constraintMatchTotal.getConstraintMatchSet().isEmpty()) {
constraintMatchTotalMap.remove(constraint.getConstraintId());
}
for (DefaultIndictment<Score_> indictment : indictments) {
indictment.removeConstraintMatch(constraintMatch);
if (indictment.getConstraintMatchSet().isEmpty()) {
indictmentMap.remove(indictment.getIndictedObject());
}
}
};
}
private DefaultIndictment<Score_> processJustification(ConstraintMatch<Score_> constraintMatch, Object indictedObject) {
DefaultIndictment<Score_> indictment = indictmentMap.computeIfAbsent(indictedObject,
key -> new DefaultIndictment<>(indictedObject, constraintMatch.getScore().zero()));
indictment.addConstraintMatch(constraintMatch);
return indictment;
}
public boolean isConstraintMatchEnabled() {
return constraintMatchEnabled;
}
public final Map<String, ConstraintMatchTotal<Score_>> getConstraintMatchTotalMap() {
// Unchecked assignment necessary as CMT and DefaultCMT incompatible in the Map generics.
return (Map) constraintMatchTotalMap;
}
public final Map<Object, Indictment<Score_>> getIndictmentMap() {
// Unchecked assignment necessary as Indictment and DefaultIndictment incompatible in the Map generics.
return (Map) indictmentMap;
}
protected final 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.");
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class BendableBigDecimalScoreContext extends ScoreContext<BendableBigDecimalScore> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final BigDecimal scoreLevelWeight;
private final IntBigDecimalConsumer softScoreLevelUpdater;
private final IntBigDecimalConsumer hardScoreLevelUpdater;
public BendableBigDecimalScoreContext(AbstractScoreInliner<BendableBigDecimalScore> parent, Constraint constraint,
BendableBigDecimalScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
BigDecimal scoreLevelWeight, IntBigDecimalConsumer hardScoreLevelUpdater,
IntBigDecimalConsumer softScoreLevelUpdater) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
this.softScoreLevelUpdater = softScoreLevelUpdater;
this.hardScoreLevelUpdater = hardScoreLevelUpdater;
}
public BendableBigDecimalScoreContext(AbstractScoreInliner<BendableBigDecimalScore> parent, Constraint constraint,
BendableBigDecimalScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount,
IntBigDecimalConsumer hardScoreLevelUpdater, IntBigDecimalConsumer softScoreLevelUpdater) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, BigDecimal.ZERO,
hardScoreLevelUpdater,
softScoreLevelUpdater);
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal softImpact = scoreLevelWeight.multiply(matchWeight);
softScoreLevelUpdater.accept(scoreLevel, softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreLevelUpdater.accept(scoreLevel, softImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableBigDecimalScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal hardImpact = scoreLevelWeight.multiply(matchWeight);
hardScoreLevelUpdater.accept(scoreLevel, hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreLevelUpdater.accept(scoreLevel, hardImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableBigDecimalScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
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;
hardScoreLevelUpdater.accept(hardScoreLevel, hardImpact);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
BigDecimal softImpact = constraintWeight.softScore(softScoreLevel).multiply(matchWeight);
softImpacts[softScoreLevel] = softImpact;
softScoreLevelUpdater.accept(softScoreLevel, softImpact);
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
hardScoreLevelUpdater.accept(hardScoreLevel, hardImpacts[hardScoreLevel].negate());
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
softScoreLevelUpdater.accept(softScoreLevel, softImpacts[softScoreLevel].negate());
}
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableBigDecimalScore.of(hardImpacts, softImpacts),
justificationsSupplier);
}
public interface IntBigDecimalConsumer {
void accept(int value1, BigDecimal value2);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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 ai.timefold.solver.constraint.streams.common.inliner.BendableBigDecimalScoreContext.IntBigDecimalConsumer;
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> {
private final BigDecimal[] hardScores;
private final BigDecimal[] softScores;
BendableBigDecimalScoreInliner(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize) {
super(constraintMatchEnabled);
hardScores = new BigDecimal[hardLevelsSize];
Arrays.fill(hardScores, BigDecimal.ZERO);
softScores = new BigDecimal[softLevelsSize];
Arrays.fill(softScores, BigDecimal.ZERO);
}
@Override
public WeightedScoreImpacter<BendableBigDecimalScore, BendableBigDecimalScoreContext> buildWeightedScoreImpacter(
Constraint constraint, BendableBigDecimalScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
Integer singleLevel = null;
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (!constraintWeight.hardOrSoftScore(i).equals(BigDecimal.ZERO)) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
IntBigDecimalConsumer hardScoreUpdater =
(scoreLevel, impact) -> this.hardScores[scoreLevel] = this.hardScores[scoreLevel].add(impact);
IntBigDecimalConsumer softScoreUpdater =
(scoreLevel, impact) -> this.softScores[scoreLevel] = this.softScores[scoreLevel].add(impact);
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),
hardScoreUpdater, softScoreUpdater);
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, hardScoreUpdater, softScoreUpdater);
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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/BendableLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class BendableLongScoreContext extends ScoreContext<BendableLongScore> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final long scoreLevelWeight;
private final IntLongConsumer softScoreLevelUpdater;
private final IntLongConsumer hardScoreLevelUpdater;
public BendableLongScoreContext(AbstractScoreInliner<BendableLongScore> parent, Constraint constraint,
BendableLongScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
long scoreLevelWeight, IntLongConsumer hardScoreLevelUpdater, IntLongConsumer softScoreLevelUpdater) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
this.softScoreLevelUpdater = softScoreLevelUpdater;
this.hardScoreLevelUpdater = hardScoreLevelUpdater;
}
public BendableLongScoreContext(AbstractScoreInliner<BendableLongScore> parent, Constraint constraint,
BendableLongScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount,
IntLongConsumer hardScoreLevelUpdater, IntLongConsumer softScoreLevelUpdater) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, -1, hardScoreLevelUpdater,
softScoreLevelUpdater);
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long softImpact = scoreLevelWeight * matchWeight;
softScoreLevelUpdater.accept(scoreLevel, softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreLevelUpdater.accept(scoreLevel, -softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableLongScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long hardImpact = scoreLevelWeight * matchWeight;
hardScoreLevelUpdater.accept(scoreLevel, hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreLevelUpdater.accept(scoreLevel, -hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableLongScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
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;
hardScoreLevelUpdater.accept(hardScoreLevel, hardImpact);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
long softImpact = constraintWeight.softScore(softScoreLevel) * matchWeight;
softImpacts[softScoreLevel] = softImpact;
softScoreLevelUpdater.accept(softScoreLevel, softImpact);
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
hardScoreLevelUpdater.accept(hardScoreLevel, -hardImpacts[hardScoreLevel]);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
softScoreLevelUpdater.accept(softScoreLevel, -softImpacts[softScoreLevel]);
}
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableLongScore.of(hardImpacts, softImpacts),
justificationsSupplier);
}
public interface IntLongConsumer {
void accept(int value1, long value2);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/BendableLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Arrays;
import ai.timefold.solver.constraint.streams.common.inliner.BendableLongScoreContext.IntLongConsumer;
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> {
private final long[] hardScores;
private final long[] softScores;
BendableLongScoreInliner(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize) {
super(constraintMatchEnabled);
hardScores = new long[hardLevelsSize];
softScores = new long[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableLongScore, BendableLongScoreContext> buildWeightedScoreImpacter(Constraint constraint,
BendableLongScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
Integer singleLevel = null;
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
IntLongConsumer hardScoreUpdater = (scoreLevel, impact) -> this.hardScores[scoreLevel] += impact;
IntLongConsumer softScoreUpdater = (scoreLevel, impact) -> this.softScores[scoreLevel] += impact;
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),
hardScoreUpdater, softScoreUpdater);
if (isHardScore) {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
JustificationsSupplier justificationSupplier) -> ctx.changeHardScoreBy(impact, justificationSupplier));
} else {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
JustificationsSupplier justificationSupplier) -> ctx.changeSoftScoreBy(impact, justificationSupplier));
}
} else {
BendableLongScoreContext context = new BendableLongScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, hardScoreUpdater, softScoreUpdater);
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
JustificationsSupplier justificationSupplier) -> ctx.changeScoreBy(impact, justificationSupplier));
}
}
@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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/BendableScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class BendableScoreContext extends ScoreContext<BendableScore> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final int scoreLevelWeight;
private final IntBiConsumer softScoreLevelUpdater;
private final IntBiConsumer hardScoreLevelUpdater;
public BendableScoreContext(AbstractScoreInliner<BendableScore> parent, Constraint constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
int scoreLevelWeight, IntBiConsumer hardScoreLevelUpdater, IntBiConsumer softScoreLevelUpdater) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
this.softScoreLevelUpdater = softScoreLevelUpdater;
this.hardScoreLevelUpdater = hardScoreLevelUpdater;
}
public BendableScoreContext(AbstractScoreInliner<BendableScore> parent, Constraint constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount,
IntBiConsumer hardScoreLevelUpdater, IntBiConsumer softScoreLevelUpdater) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, -1, hardScoreLevelUpdater,
softScoreLevelUpdater);
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int softImpact = scoreLevelWeight * matchWeight;
softScoreLevelUpdater.accept(scoreLevel, softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreLevelUpdater.accept(scoreLevel, -softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int hardImpact = scoreLevelWeight * matchWeight;
hardScoreLevelUpdater.accept(scoreLevel, hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreLevelUpdater.accept(scoreLevel, -hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
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;
hardScoreLevelUpdater.accept(hardScoreLevel, hardImpact);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
int softImpact = constraintWeight.softScore(softScoreLevel) * matchWeight;
softImpacts[softScoreLevel] = softImpact;
softScoreLevelUpdater.accept(softScoreLevel, softImpact);
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
hardScoreLevelUpdater.accept(hardScoreLevel, -hardImpacts[hardScoreLevel]);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
softScoreLevelUpdater.accept(softScoreLevel, -softImpacts[softScoreLevel]);
}
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableScore.of(hardImpacts, softImpacts), justificationsSupplier);
}
public interface IntBiConsumer {
void accept(int value1, int value2);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/BendableScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Arrays;
import ai.timefold.solver.constraint.streams.common.inliner.BendableScoreContext.IntBiConsumer;
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> {
private final int[] hardScores;
private final int[] softScores;
BendableScoreInliner(boolean constraintMatchEnabled, int hardLevelsSize, int softLevelsSize) {
super(constraintMatchEnabled);
hardScores = new int[hardLevelsSize];
softScores = new int[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableScore, BendableScoreContext> buildWeightedScoreImpacter(Constraint constraint,
BendableScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
Integer singleLevel = null;
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
IntBiConsumer hardScoreUpdater = (scoreLevel, impact) -> this.hardScores[scoreLevel] += impact;
IntBiConsumer softScoreUpdater = (scoreLevel, impact) -> this.softScores[scoreLevel] += impact;
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),
hardScoreUpdater, softScoreUpdater);
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, hardScoreUpdater, softScoreUpdater);
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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/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, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, BigDecimal.valueOf(matchWeight), justificationsSupplier);
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, BigDecimal.valueOf(matchWeight), justificationsSupplier);
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, matchWeight, justificationsSupplier);
}
@Override
public Context_ getContext() {
return context;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftBigDecimalScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.function.Consumer;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftBigDecimalScoreContext extends ScoreContext<HardMediumSoftBigDecimalScore> {
private final Consumer<BigDecimal> softScoreUpdater;
private final Consumer<BigDecimal> mediumScoreUpdater;
private final Consumer<BigDecimal> hardScoreUpdater;
public HardMediumSoftBigDecimalScoreContext(AbstractScoreInliner<HardMediumSoftBigDecimalScore> parent,
Constraint constraint, HardMediumSoftBigDecimalScore constraintWeight, Consumer<BigDecimal> hardScoreUpdater,
Consumer<BigDecimal> mediumScoreUpdater, Consumer<BigDecimal> softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.mediumScoreUpdater = mediumScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(softImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofSoft(softImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
mediumScoreUpdater.accept(mediumImpact);
UndoScoreImpacter undoScoreImpact = () -> mediumScoreUpdater.accept(mediumImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofMedium(mediumImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(hardImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofHard(hardImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
mediumScoreUpdater.accept(mediumImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(hardImpact.negate());
mediumScoreUpdater.accept(mediumImpact.negate());
softScoreUpdater.accept(softImpact.negate());
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
HardMediumSoftBigDecimalScore.of(hardImpact, mediumImpact, softImpact), justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftBigDecimalScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftBigDecimalScoreInliner extends AbstractScoreInliner<HardMediumSoftBigDecimalScore> {
private BigDecimal hardScore = BigDecimal.ZERO;
private BigDecimal mediumScore = BigDecimal.ZERO;
private BigDecimal softScore = BigDecimal.ZERO;
HardMediumSoftBigDecimalScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftBigDecimalScore, HardMediumSoftBigDecimalScoreContext>
buildWeightedScoreImpacter(Constraint constraint,
HardMediumSoftBigDecimalScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
BigDecimal hardConstraintWeight = constraintWeight.hardScore();
BigDecimal mediumConstraintWeight = constraintWeight.mediumScore();
BigDecimal softConstraintWeight = constraintWeight.softScore();
HardMediumSoftBigDecimalScoreContext context =
new HardMediumSoftBigDecimalScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore = this.hardScore.add(impact),
impact -> this.mediumScore = this.mediumScore.add(impact),
impact -> this.softScore = this.softScore.add(impact));
if (mediumConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeHardScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeMediumScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && mediumConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeScoreBy);
}
}
@Override
public HardMediumSoftBigDecimalScore extractScore(int initScore) {
return HardMediumSoftBigDecimalScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.function.LongConsumer;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftLongScoreContext extends ScoreContext<HardMediumSoftLongScore> {
private final LongConsumer softScoreUpdater;
private final LongConsumer mediumScoreUpdater;
private final LongConsumer hardScoreUpdater;
public HardMediumSoftLongScoreContext(AbstractScoreInliner<HardMediumSoftLongScore> parent, Constraint constraint,
HardMediumSoftLongScore constraintWeight, LongConsumer hardScoreUpdater, LongConsumer mediumScoreUpdater,
LongConsumer softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.mediumScoreUpdater = mediumScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long softImpact = constraintWeight.softScore() * matchWeight;
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(-softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
mediumScoreUpdater.accept(mediumImpact);
UndoScoreImpacter undoScoreImpact = () -> mediumScoreUpdater.accept(-mediumImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofMedium(mediumImpact),
justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(-hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
long softImpact = constraintWeight.softScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
mediumScoreUpdater.accept(mediumImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(-hardImpact);
mediumScoreUpdater.accept(-mediumImpact);
softScoreUpdater.accept(-softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.of(hardImpact, mediumImpact, softImpact),
justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftLongScoreInliner extends AbstractScoreInliner<HardMediumSoftLongScore> {
private long hardScore;
private long mediumScore;
private long softScore;
HardMediumSoftLongScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftLongScore, HardMediumSoftLongScoreContext> buildWeightedScoreImpacter(
Constraint constraint, HardMediumSoftLongScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
long hardConstraintWeight = constraintWeight.hardScore();
long mediumConstraintWeight = constraintWeight.mediumScore();
long softConstraintWeight = constraintWeight.softScore();
HardMediumSoftLongScoreContext context = new HardMediumSoftLongScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore += impact, impact -> this.mediumScore += impact,
impact -> this.softScore += impact);
if (mediumConstraintWeight == 0L && softConstraintWeight == 0L) {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeHardScoreBy(matchWeight, justificationsSupplier));
} else if (hardConstraintWeight == 0L && softConstraintWeight == 0L) {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeMediumScoreBy(matchWeight, justificationsSupplier));
} else if (hardConstraintWeight == 0L && mediumConstraintWeight == 0L) {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeSoftScoreBy(matchWeight, justificationsSupplier));
} else {
return WeightedScoreImpacter.of(context,
(HardMediumSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeScoreBy(matchWeight, justificationsSupplier));
}
}
@Override
public HardMediumSoftLongScore extractScore(int initScore) {
return HardMediumSoftLongScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.function.IntConsumer;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftScoreContext extends ScoreContext<HardMediumSoftScore> {
private final IntConsumer softScoreUpdater;
private final IntConsumer mediumScoreUpdater;
private final IntConsumer hardScoreUpdater;
public HardMediumSoftScoreContext(AbstractScoreInliner<HardMediumSoftScore> parent, Constraint constraint,
HardMediumSoftScore constraintWeight, IntConsumer hardScoreUpdater, IntConsumer mediumScoreUpdater,
IntConsumer softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.mediumScoreUpdater = mediumScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int softImpact = constraintWeight.softScore() * matchWeight;
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(-softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int mediumImpact = constraintWeight.mediumScore() * matchWeight;
mediumScoreUpdater.accept(mediumImpact);
UndoScoreImpacter undoScoreImpact = () -> mediumScoreUpdater.accept(-mediumImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.ofMedium(mediumImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(-hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
int mediumImpact = constraintWeight.mediumScore() * matchWeight;
int softImpact = constraintWeight.softScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
mediumScoreUpdater.accept(mediumImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(-hardImpact);
mediumScoreUpdater.accept(-mediumImpact);
softScoreUpdater.accept(-softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftScore.of(hardImpact, mediumImpact, softImpact),
justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardMediumSoftScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardMediumSoftScoreInliner extends AbstractScoreInliner<HardMediumSoftScore> {
private int hardScore;
private int mediumScore;
private int softScore;
HardMediumSoftScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardMediumSoftScore, HardMediumSoftScoreContext> buildWeightedScoreImpacter(
Constraint constraint, HardMediumSoftScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
int hardConstraintWeight = constraintWeight.hardScore();
int mediumConstraintWeight = constraintWeight.mediumScore();
int softConstraintWeight = constraintWeight.softScore();
HardMediumSoftScoreContext context =
new HardMediumSoftScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore += impact, impact -> this.mediumScore += impact,
impact -> this.softScore += impact);
if (mediumConstraintWeight == 0 && softConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeHardScoreBy);
} else if (hardConstraintWeight == 0 && softConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeMediumScoreBy);
} else if (hardConstraintWeight == 0 && mediumConstraintWeight == 0) {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardMediumSoftScoreContext::changeScoreBy);
}
}
@Override
public HardMediumSoftScore extractScore(int initScore) {
return HardMediumSoftScore.ofUninitialized(initScore, hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardSoftBigDecimalScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.function.Consumer;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftBigDecimalScoreContext extends ScoreContext<HardSoftBigDecimalScore> {
private final Consumer<BigDecimal> softScoreUpdater;
private final Consumer<BigDecimal> hardScoreUpdater;
public HardSoftBigDecimalScoreContext(AbstractScoreInliner<HardSoftBigDecimalScore> parent, Constraint constraint,
HardSoftBigDecimalScore constraintWeight, Consumer<BigDecimal> hardScoreUpdater,
Consumer<BigDecimal> softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(softImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(hardImpact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
hardScoreUpdater.accept(hardImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(hardImpact.negate());
softScoreUpdater.accept(softImpact.negate());
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftBigDecimalScore.of(hardImpact, softImpact),
justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardSoftBigDecimalScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftBigDecimalScoreInliner extends AbstractScoreInliner<HardSoftBigDecimalScore> {
private BigDecimal hardScore = BigDecimal.ZERO;
private BigDecimal softScore = BigDecimal.ZERO;
HardSoftBigDecimalScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftBigDecimalScore, HardSoftBigDecimalScoreContext> buildWeightedScoreImpacter(
Constraint constraint, HardSoftBigDecimalScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
HardSoftBigDecimalScoreContext context =
new HardSoftBigDecimalScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore = this.hardScore.add(impact),
impact -> this.softScore = this.softScore.add(impact));
if (constraintWeight.softScore().equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeHardScoreBy);
} else if (constraintWeight.hardScore().equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardSoftBigDecimalScoreContext::changeScoreBy);
}
}
@Override
public HardSoftBigDecimalScore extractScore(int initScore) {
return HardSoftBigDecimalScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardSoftLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.function.LongConsumer;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftLongScoreContext extends ScoreContext<HardSoftLongScore> {
private final LongConsumer softScoreUpdater;
private final LongConsumer hardScoreUpdater;
public HardSoftLongScoreContext(AbstractScoreInliner<HardSoftLongScore> parent, Constraint constraint,
HardSoftLongScore constraintWeight, LongConsumer hardScoreUpdater, LongConsumer softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long softImpact = constraintWeight.softScore() * matchWeight;
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(-softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(-hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
long softImpact = constraintWeight.softScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(-hardImpact);
softScoreUpdater.accept(-softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftLongScore.of(hardImpact, softImpact), justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardSoftLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftLongScoreInliner extends AbstractScoreInliner<HardSoftLongScore> {
private long hardScore;
private long softScore;
HardSoftLongScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftLongScore, HardSoftLongScoreContext> buildWeightedScoreImpacter(Constraint constraint,
HardSoftLongScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
HardSoftLongScoreContext context =
new HardSoftLongScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore += impact, impact -> this.softScore += impact);
if (constraintWeight.softScore() == 0L) {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeHardScoreBy(matchWeight, justificationsSupplier));
} else if (constraintWeight.hardScore() == 0L) {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeSoftScoreBy(matchWeight, justificationsSupplier));
} else {
return WeightedScoreImpacter.of(context,
(HardSoftLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeScoreBy(matchWeight, justificationsSupplier));
}
}
@Override
public HardSoftLongScore extractScore(int initScore) {
return HardSoftLongScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardSoftScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.function.IntConsumer;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftScoreContext extends ScoreContext<HardSoftScore> {
private final IntConsumer softScoreUpdater;
private final IntConsumer hardScoreUpdater;
public HardSoftScoreContext(AbstractScoreInliner<HardSoftScore> parent, Constraint constraint,
HardSoftScore constraintWeight, IntConsumer hardScoreUpdater, IntConsumer softScoreUpdater) {
super(parent, constraint, constraintWeight);
this.softScoreUpdater = softScoreUpdater;
this.hardScoreUpdater = hardScoreUpdater;
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int softImpact = constraintWeight.softScore() * matchWeight;
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> softScoreUpdater.accept(-softImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.ofSoft(softImpact), justificationsSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> hardScoreUpdater.accept(-hardImpact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.ofHard(hardImpact), justificationsSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int hardImpact = constraintWeight.hardScore() * matchWeight;
int softImpact = constraintWeight.softScore() * matchWeight;
hardScoreUpdater.accept(hardImpact);
softScoreUpdater.accept(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
hardScoreUpdater.accept(-hardImpact);
softScoreUpdater.accept(-softImpact);
};
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardSoftScore.of(hardImpact, softImpact), justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/HardSoftScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class HardSoftScoreInliner extends AbstractScoreInliner<HardSoftScore> {
private int hardScore;
private int softScore;
HardSoftScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<HardSoftScore, HardSoftScoreContext> buildWeightedScoreImpacter(Constraint constraint,
HardSoftScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
HardSoftScoreContext context = new HardSoftScoreContext(this, constraint, constraintWeight,
impact -> this.hardScore += impact, impact -> this.softScore += impact);
if (constraintWeight.softScore() == 0) {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeHardScoreBy);
} else if (constraintWeight.hardScore() == 0) {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardSoftScoreContext::changeScoreBy);
}
}
@Override
public HardSoftScore extractScore(int initScore) {
return HardSoftScore.ofUninitialized(initScore, hardScore, softScore);
}
@Override
public String toString() {
return HardSoftScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/IntWeightedScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
final class IntWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>>
implements WeightedScoreImpacter<Score_, Context_> {
private final IntImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public IntWeightedScoreImpacter(IntImpactFunction<Score_, Context_> impactFunction, Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, matchWeight, justificationsSupplier);
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, JustificationsSupplier justificationsSupplier) {
throw new UnsupportedOperationException("Impossible state: passing long into an int impacter.");
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
throw new UnsupportedOperationException("Impossible state: passing BigDecimal into an int impacter.");
}
@Override
public Context_ getContext() {
return context;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/JustificationsSupplier.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
/**
* Allows to create justifications and indictments lazily if and only if constraint matches are enabled.
*
* Justification and indictment creation is performance expensive and constraint matches are typically disabled.
* So justifications and indictments are created lazily, outside of the typical hot path.
*/
public final class JustificationsSupplier {
public static JustificationsSupplier empty() {
return new JustificationsSupplier(DefaultConstraintJustification::of, Collections::emptyList);
}
public static <A> JustificationsSupplier of(Constraint constraint,
BiFunction<A, Score<?>, ConstraintJustification> justificationMapping,
Function<A, Collection<Object>> indictedObjectsMapping,
A a) {
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
}
private static RuntimeException createJustificationException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintId()
+ ") threw an exception creating constraint justification from a tuple (" + factsToString(facts) + ").", cause);
}
private static String factsToString(Object... facts) {
return Arrays.stream(facts)
.map(Object::toString)
.collect(Collectors.joining(", ", "{", "}"));
}
private static RuntimeException createIndictmentException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintId()
+ ") threw an exception collecting indicted objects from a tuple (" + factsToString(facts) + ").", cause);
}
public static <A, B> JustificationsSupplier of(Constraint constraint,
TriFunction<A, B, Score<?>, ConstraintJustification> justificationMapping,
BiFunction<A, B, Collection<Object>> indictedObjectsMapping,
A a, B b) {
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, b, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a, b);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
}
public static <A, B, C> JustificationsSupplier of(Constraint constraint,
QuadFunction<A, B, C, Score<?>, ConstraintJustification> justificationMapping,
TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping,
A a, B b, C c) {
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, b, c, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a, b, c);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
}
public static <A, B, C, D> JustificationsSupplier of(Constraint constraint,
PentaFunction<A, B, C, D, Score<?>, ConstraintJustification> justificationMapping,
QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping,
A a, B b, C c, D d) {
Function<Score<?>, ConstraintJustification> explainingJustificationMapping = impact -> {
try {
return justificationMapping.apply(a, b, c, d, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c, d);
}
};
Supplier<Collection<Object>> explainingIndictedObjectsSupplier = () -> {
try {
return indictedObjectsMapping.apply(a, b, c, d);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c, d);
}
};
return new JustificationsSupplier(explainingJustificationMapping, explainingIndictedObjectsSupplier);
}
private final Function<Score<?>, ConstraintJustification> constraintJustificationSupplier;
private final Supplier<Collection<Object>> indictedObjectsSupplier;
private JustificationsSupplier(Function<Score<?>, ConstraintJustification> constraintJustificationSupplier,
Supplier<Collection<Object>> indictedObjectsSupplier) {
this.constraintJustificationSupplier = Objects.requireNonNull(constraintJustificationSupplier);
this.indictedObjectsSupplier = Objects.requireNonNull(indictedObjectsSupplier);
}
public ConstraintJustification createConstraintJustification(Score<?> impact) {
return constraintJustificationSupplier.apply(impact);
}
public Collection<Object> createIndictedObjects() {
return indictedObjectsSupplier.get();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/LongWeightedScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
final class LongWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>>
implements WeightedScoreImpacter<Score_, Context_> {
private final LongImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public LongWeightedScoreImpacter(LongImpactFunction<Score_, Context_> impactFunction, Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, matchWeight, justificationsSupplier); // int can be cast to long
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, JustificationsSupplier justificationsSupplier) {
return impactFunction.impact(context, matchWeight, justificationsSupplier);
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
throw new UnsupportedOperationException("Impossible state: passing BigDecimal into a long impacter.");
}
@Override
public Context_ getContext() {
return context;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/ScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
public abstract class ScoreContext<Score_ extends Score<Score_>> {
private final AbstractScoreInliner<Score_> parent;
protected final Constraint constraint;
protected final Score_ constraintWeight;
protected final boolean constraintMatchEnabled;
protected ScoreContext(AbstractScoreInliner<Score_> parent, Constraint constraint, Score_ constraintWeight) {
this.parent = parent;
this.constraint = constraint;
this.constraintWeight = constraintWeight;
this.constraintMatchEnabled = parent.constraintMatchEnabled;
}
public Constraint getConstraint() {
return constraint;
}
public Score_ getConstraintWeight() {
return constraintWeight;
}
public boolean isConstraintMatchEnabled() {
return constraintMatchEnabled;
}
protected UndoScoreImpacter impactWithConstraintMatch(UndoScoreImpacter undoScoreImpact, Score_ score,
JustificationsSupplier justificationsSupplier) {
Runnable undoConstraintMatch = parent.addConstraintMatch(constraint, constraintWeight, score, justificationsSupplier);
return () -> {
undoScoreImpact.run();
undoConstraintMatch.run();
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/SimpleBigDecimalScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import java.util.function.Consumer;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleBigDecimalScoreContext extends ScoreContext<SimpleBigDecimalScore> {
private final Consumer<BigDecimal> scoreUpdater;
public SimpleBigDecimalScoreContext(AbstractScoreInliner<SimpleBigDecimalScore> parent, Constraint constraint,
SimpleBigDecimalScore constraintWeight, Consumer<BigDecimal> scoreUpdater) {
super(parent, constraint, constraintWeight);
this.scoreUpdater = scoreUpdater;
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier) {
BigDecimal impact = constraintWeight.score().multiply(matchWeight);
scoreUpdater.accept(impact);
UndoScoreImpacter undoScoreImpact = () -> scoreUpdater.accept(impact.negate());
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleBigDecimalScore.of(impact), justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/SimpleBigDecimalScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleBigDecimalScoreInliner extends AbstractScoreInliner<SimpleBigDecimalScore> {
private BigDecimal score = BigDecimal.ZERO;
SimpleBigDecimalScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleBigDecimalScore, SimpleBigDecimalScoreContext> buildWeightedScoreImpacter(
Constraint constraint, SimpleBigDecimalScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
SimpleBigDecimalScoreContext context = new SimpleBigDecimalScoreContext(this, constraint, constraintWeight,
impact -> this.score = this.score.add(impact));
return WeightedScoreImpacter.of(context, SimpleBigDecimalScoreContext::changeScoreBy);
}
@Override
public SimpleBigDecimalScore extractScore(int initScore) {
return SimpleBigDecimalScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/SimpleLongScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.function.LongConsumer;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleLongScoreContext extends ScoreContext<SimpleLongScore> {
private final LongConsumer scoreUpdater;
public SimpleLongScoreContext(AbstractScoreInliner<SimpleLongScore> parent, Constraint constraint,
SimpleLongScore constraintWeight, LongConsumer scoreUpdater) {
super(parent, constraint, constraintWeight);
this.scoreUpdater = scoreUpdater;
}
public UndoScoreImpacter changeScoreBy(long matchWeight, JustificationsSupplier justificationsSupplier) {
long impact = constraintWeight.score() * matchWeight;
scoreUpdater.accept(impact);
UndoScoreImpacter undoScoreImpact = () -> scoreUpdater.accept(-impact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleLongScore.of(impact), justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/SimpleLongScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleLongScoreInliner extends AbstractScoreInliner<SimpleLongScore> {
private long score;
SimpleLongScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleLongScore, SimpleLongScoreContext> buildWeightedScoreImpacter(Constraint constraint,
SimpleLongScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
SimpleLongScoreContext context = new SimpleLongScoreContext(this, constraint, constraintWeight,
impact -> this.score += impact);
return WeightedScoreImpacter.of(context,
(SimpleLongScoreContext ctx, long matchWeight, JustificationsSupplier justificationsSupplier) -> ctx
.changeScoreBy(matchWeight, justificationsSupplier));
}
@Override
public SimpleLongScore extractScore(int initScore) {
return SimpleLongScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/SimpleScoreContext.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.util.function.IntConsumer;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleScoreContext extends ScoreContext<SimpleScore> {
private final IntConsumer scoreUpdater;
public SimpleScoreContext(AbstractScoreInliner<SimpleScore> parent, Constraint constraint, SimpleScore constraintWeight,
IntConsumer scoreUpdater) {
super(parent, constraint, constraintWeight);
this.scoreUpdater = scoreUpdater;
}
public UndoScoreImpacter changeScoreBy(int matchWeight, JustificationsSupplier justificationsSupplier) {
int impact = constraintWeight.score() * matchWeight;
scoreUpdater.accept(impact);
UndoScoreImpacter undoScoreImpact = () -> scoreUpdater.accept(-impact);
if (!constraintMatchEnabled) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, SimpleScore.of(impact), justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/SimpleScoreInliner.java | package ai.timefold.solver.constraint.streams.common.inliner;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
final class SimpleScoreInliner extends AbstractScoreInliner<SimpleScore> {
private int score;
SimpleScoreInliner(boolean constraintMatchEnabled) {
super(constraintMatchEnabled);
}
@Override
public WeightedScoreImpacter<SimpleScore, SimpleScoreContext> buildWeightedScoreImpacter(Constraint constraint,
SimpleScore constraintWeight) {
validateConstraintWeight(constraint, constraintWeight);
SimpleScoreContext context = new SimpleScoreContext(this, constraint, constraintWeight,
impact -> this.score += impact);
return WeightedScoreImpacter.of(context, SimpleScoreContext::changeScoreBy);
}
@Override
public SimpleScore extractScore(int initScore) {
return SimpleScore.ofUninitialized(initScore, score);
}
@Override
public String toString() {
return SimpleScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/inliner/WeightedScoreImpacter.java | package ai.timefold.solver.constraint.streams.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.score.Score;
/**
* There are several valid ways how an impacter could be called from a constraint stream:
*
* <ul>
* <li>{@code .penalize(..., (int) 1)}</li>
* <li>{@code .penalizeLong(..., (int) 1)}</li>
* <li>{@code .penalizeLong(..., (long) 1)}</li>
* <li>{@code .penalizeBigDecimal(..., (int) 1)}</li>
* <li>{@code .penalizeBigDecimal(..., (long) 1)}</li>
* <li>{@code .penalizeBigDecimal(..., BigDecimal.ONE)}</li>
* <li>Plus reward variants of the above.</li>
* </ul>
*
* An implementation of this interface can throw an {@link UnsupportedOperationException}
* for the method types it doesn't support. The CS API guarantees no types are mixed. For example,
* a {@link BigDecimal} parameter method won't be called on an instance built with an {@link IntImpactFunction}.
*/
public interface WeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>> {
static <Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>> WeightedScoreImpacter<Score_, Context_>
of(Context_ context, IntImpactFunction<Score_, Context_> impactFunction) {
return new IntWeightedScoreImpacter<>(impactFunction, context);
}
static <Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>> WeightedScoreImpacter<Score_, Context_>
of(Context_ context, LongImpactFunction<Score_, Context_> impactFunction) {
return new LongWeightedScoreImpacter<>(impactFunction, context);
}
static <Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>> WeightedScoreImpacter<Score_, Context_>
of(Context_ context, BigDecimalImpactFunction<Score_, Context_> impactFunction) {
return new BigDecimalWeightedScoreImpacter<>(impactFunction, context);
}
/**
* @param matchWeight never null
* @param justificationsSupplier ignored unless constraint match enableds
* @return never null
*/
UndoScoreImpacter impactScore(int matchWeight, JustificationsSupplier justificationsSupplier);
/**
* @param matchWeight never null
* @param justificationsSupplier ignored unless constraint match enabled
* @return never null
*/
UndoScoreImpacter impactScore(long matchWeight, JustificationsSupplier justificationsSupplier);
/**
* @param matchWeight never null
* @param justificationsSupplier ignored unless constraint match enabled
* @return never null
*/
UndoScoreImpacter impactScore(BigDecimal matchWeight, JustificationsSupplier justificationsSupplier);
Context_ getContext();
@FunctionalInterface
interface IntImpactFunction<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>> {
UndoScoreImpacter impact(Context_ context, int matchWeight, JustificationsSupplier justificationsSupplier);
}
@FunctionalInterface
interface LongImpactFunction<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>> {
UndoScoreImpacter impact(Context_ context, long matchWeight, JustificationsSupplier justificationsSupplier);
}
@FunctionalInterface
interface BigDecimalImpactFunction<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_>> {
UndoScoreImpacter impact(Context_ context, BigDecimal matchWeight, JustificationsSupplier justificationsSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/penta/DefaultPentaJoiner.java | package ai.timefold.solver.constraint.streams.common.penta;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.penta.PentaJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultPentaJoiner<A, B, C, D, E> extends AbstractJoiner<E> implements PentaJoiner<A, B, C, D, E> {
private static final DefaultPentaJoiner NONE =
new DefaultPentaJoiner(new QuadFunction[0], new JoinerType[0], new Function[0]);
private final QuadFunction<A, B, C, D, ?>[] leftMappings;
public <Property_> DefaultPentaJoiner(QuadFunction<A, B, C, D, Property_> leftMapping, JoinerType joinerType,
Function<E, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new QuadFunction[] { leftMapping };
}
private <Property_> DefaultPentaJoiner(QuadFunction<A, B, C, D, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<E, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C, D, E> DefaultPentaJoiner<A, B, C, D, E> merge(List<DefaultPentaJoiner<A, B, C, D, E>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultPentaJoiner::and);
}
@Override
public DefaultPentaJoiner<A, B, C, D, E> and(PentaJoiner<A, B, C, D, E> otherJoiner) {
DefaultPentaJoiner<A, B, C, D, E> castJoiner = (DefaultPentaJoiner<A, B, C, D, E>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
QuadFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoinerCount; i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultPentaJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public QuadFunction<A, B, C, D, Object> getLeftMapping(int index) {
return (QuadFunction<A, B, C, D, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c, D d, E e) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b, c, d);
Object rightMapping = getRightMapping(i).apply(e);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof DefaultPentaJoiner)) {
return false;
}
DefaultPentaJoiner<?, ?, ?, ?, ?> other = (DefaultPentaJoiner<?, ?, ?, ?, ?>) o;
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
@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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/quad/DefaultQuadJoiner.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultQuadJoiner<A, B, C, D> extends AbstractJoiner<D> implements QuadJoiner<A, B, C, D> {
private static final DefaultQuadJoiner NONE =
new DefaultQuadJoiner(new TriFunction[0], new JoinerType[0], new Function[0]);
private final TriFunction<A, B, C, ?>[] leftMappings;
public <Property_> DefaultQuadJoiner(TriFunction<A, B, C, Property_> leftMapping, JoinerType joinerType,
Function<D, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new TriFunction[] { leftMapping };
}
private <Property_> DefaultQuadJoiner(TriFunction<A, B, C, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<D, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C, D> DefaultQuadJoiner<A, B, C, D> merge(List<DefaultQuadJoiner<A, B, C, D>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultQuadJoiner::and);
}
@Override
public DefaultQuadJoiner<A, B, C, D> and(QuadJoiner<A, B, C, D> otherJoiner) {
DefaultQuadJoiner<A, B, C, D> castJoiner = (DefaultQuadJoiner<A, B, C, D>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
TriFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoiner.getJoinerCount(); i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultQuadJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public TriFunction<A, B, C, Object> getLeftMapping(int index) {
return (TriFunction<A, B, C, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c, D d) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b, c);
Object rightMapping = getRightMapping(i).apply(d);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof DefaultQuadJoiner)) {
return false;
}
DefaultQuadJoiner<?, ?, ?, ?> other = (DefaultQuadJoiner<?, ?, ?, ?>) o;
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
@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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/quad/InnerQuadConstraintStream.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
public interface InnerQuadConstraintStream<A, B, C, D> extends QuadConstraintStream<A, B, C, D> {
static <A, B, C, D> PentaFunction<A, B, C, D, Score<?>, DefaultConstraintJustification>
createDefaultJustificationMapping() {
return (a, b, c, d, score) -> DefaultConstraintJustification.of(score, a, b, c, d);
}
static <A, B, C, D> QuadFunction<A, B, C, D, Collection<?>> createDefaultIndictedObjectsMapping() {
return List::of;
}
/**
* 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 QuadConstraintStream<A, B, C, D> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy((a, b, c, d) -> a, (a, b, c, d) -> b, (a, b, c, d) -> c, (a, b, c, d) -> d);
}
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> penalize(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> penalizeLong(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> penalizeBigDecimal(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> penalizeConfigurable(ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> penalizeConfigurableLong(ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?>
penalizeConfigurableBigDecimal(QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> reward(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> rewardLong(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> rewardBigDecimal(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> rewardConfigurable(ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> rewardConfigurableLong(ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?>
rewardConfigurableBigDecimal(QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> impact(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> impactLong(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> impactBigDecimal(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> impactConfigurable(ToIntQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?> impactConfigurableLong(ToLongQuadFunction<A, B, C, D> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default QuadConstraintBuilder<A, B, C, D, ?>
impactConfigurableBigDecimal(QuadFunction<A, B, C, D, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToIntQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
ToLongQuadFunction<A, B, C, D> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> QuadConstraintBuilder<A, B, C, D, Score_> innerImpact(Score_ constraintWeight,
QuadFunction<A, B, C, D, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType);
@Override
default Constraint penalize(String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint penalize(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint reward(String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint reward(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint impact(String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint impact(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/quad/QuadConstraintBuilderImpl.java | package ai.timefold.solver.constraint.streams.common.quad;
import java.util.Collection;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintBuilder;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintBuilder;
public final class QuadConstraintBuilderImpl<A, B, C, D, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements QuadConstraintBuilder<A, B, C, D, Score_> {
private PentaFunction<A, B, C, D, Score_, ConstraintJustification> justificationMapping;
private QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping;
public QuadConstraintBuilderImpl(QuadConstraintConstructor<A, B, C, D, Score_> constraintConstructor,
ScoreImpactType impactType, Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected PentaFunction<A, B, C, D, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> QuadConstraintBuilder<A, B, C, D, Score_> justifyWith(
PentaFunction<A, B, C, D, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("Justification mapping already set (" + justificationMapping + ").");
}
this.justificationMapping =
(PentaFunction<A, B, C, D, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected QuadFunction<A, B, C, D, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public QuadConstraintBuilder<A, B, C, D, Score_>
indictWith(QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("Indicted objects' mapping already set (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/tri/DefaultTriJoiner.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.util.Arrays;
import java.util.List;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractJoiner;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
import ai.timefold.solver.core.impl.score.stream.JoinerType;
public final class DefaultTriJoiner<A, B, C> extends AbstractJoiner<C> implements TriJoiner<A, B, C> {
private static final DefaultTriJoiner NONE =
new DefaultTriJoiner(new BiFunction[0], new JoinerType[0], new Function[0]);
private final BiFunction<A, B, ?>[] leftMappings;
public <Property_> DefaultTriJoiner(BiFunction<A, B, Property_> leftMapping, JoinerType joinerType,
Function<C, Property_> rightMapping) {
super(rightMapping, joinerType);
this.leftMappings = new BiFunction[] { leftMapping };
}
private <Property_> DefaultTriJoiner(BiFunction<A, B, Property_>[] leftMappings, JoinerType[] joinerTypes,
Function<C, Property_>[] rightMappings) {
super(rightMappings, joinerTypes);
this.leftMappings = leftMappings;
}
public static <A, B, C> DefaultTriJoiner<A, B, C> merge(List<DefaultTriJoiner<A, B, C>> joinerList) {
if (joinerList.size() == 1) {
return joinerList.get(0);
}
return joinerList.stream().reduce(NONE, DefaultTriJoiner::and);
}
@Override
public DefaultTriJoiner<A, B, C> and(TriJoiner<A, B, C> otherJoiner) {
DefaultTriJoiner<A, B, C> castJoiner = (DefaultTriJoiner<A, B, C>) otherJoiner;
int joinerCount = getJoinerCount();
int castJoinerCount = castJoiner.getJoinerCount();
int newJoinerCount = joinerCount + castJoinerCount;
JoinerType[] newJoinerTypes = Arrays.copyOf(this.joinerTypes, newJoinerCount);
BiFunction[] newLeftMappings = Arrays.copyOf(this.leftMappings, newJoinerCount);
Function[] newRightMappings = Arrays.copyOf(this.rightMappings, newJoinerCount);
for (int i = 0; i < castJoinerCount; i++) {
int newJoinerIndex = i + joinerCount;
newJoinerTypes[newJoinerIndex] = castJoiner.getJoinerType(i);
newLeftMappings[newJoinerIndex] = castJoiner.getLeftMapping(i);
newRightMappings[newJoinerIndex] = castJoiner.getRightMapping(i);
}
return new DefaultTriJoiner<>(newLeftMappings, newJoinerTypes, newRightMappings);
}
public BiFunction<A, B, Object> getLeftMapping(int index) {
return (BiFunction<A, B, Object>) leftMappings[index];
}
public boolean matches(A a, B b, C c) {
int joinerCount = getJoinerCount();
for (int i = 0; i < joinerCount; i++) {
JoinerType joinerType = getJoinerType(i);
Object leftMapping = getLeftMapping(i).apply(a, b);
Object rightMapping = getRightMapping(i).apply(c);
if (!joinerType.matches(leftMapping, rightMapping)) {
return false;
}
}
return true;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof DefaultTriJoiner)) {
return false;
}
DefaultTriJoiner<?, ?, ?> other = (DefaultTriJoiner<?, ?, ?>) o;
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
@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-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/tri/InnerTriConstraintStream.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintStream;
import ai.timefold.solver.core.api.score.stream.quad.QuadJoiner;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
public interface InnerTriConstraintStream<A, B, C> extends TriConstraintStream<A, B, C> {
static <A, B, C> QuadFunction<A, B, C, Score<?>, DefaultConstraintJustification> createDefaultJustificationMapping() {
return (a, b, c, score) -> DefaultConstraintJustification.of(score, a, b, c);
}
static <A, B, C> TriFunction<A, B, C, Collection<?>> createDefaultIndictedObjectsMapping() {
return List::of;
}
RetrievalSemantics getRetrievalSemantics();
/**
* This method will return true if the constraint stream is guaranteed to only produce distinct tuples.
* See {@link #distinct()} for details.
*
* @return true if the guarantee of distinct tuples is provided
*/
boolean guaranteesDistinct();
@Override
default <D> QuadConstraintStream<A, B, C, D> join(Class<D> otherClass, QuadJoiner<A, B, C, D>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return join(getConstraintFactory().forEach(otherClass), joiners);
} else {
return join(getConstraintFactory().from(otherClass), joiners);
}
}
@Override
default TriConstraintStream<A, B, C> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy((a, b, c) -> a, (a, b, c) -> b, (a, b, c) -> c);
}
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> penalize(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> penalizeLong(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> penalizeBigDecimal(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default TriConstraintBuilder<A, B, C, ?> penalizeConfigurable(ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default TriConstraintBuilder<A, B, C, ?> penalizeConfigurableLong(ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default TriConstraintBuilder<A, B, C, ?> penalizeConfigurableBigDecimal(TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> reward(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> rewardLong(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> rewardBigDecimal(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default TriConstraintBuilder<A, B, C, ?> rewardConfigurable(ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default TriConstraintBuilder<A, B, C, ?> rewardConfigurableLong(ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default TriConstraintBuilder<A, B, C, ?> rewardConfigurableBigDecimal(TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> impact(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> impactLong(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> impactBigDecimal(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default TriConstraintBuilder<A, B, C, ?> impactConfigurable(ToIntTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default TriConstraintBuilder<A, B, C, ?> impactConfigurableLong(ToLongTriFunction<A, B, C> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default TriConstraintBuilder<A, B, C, ?> impactConfigurableBigDecimal(TriFunction<A, B, C, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToIntTriFunction<A, B, C> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
ToLongTriFunction<A, B, C> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> TriConstraintBuilder<A, B, C, Score_> innerImpact(Score_ constraintWeight,
TriFunction<A, B, C, BigDecimal> matchWeigher,
ScoreImpactType scoreImpactType);
@Override
default Constraint penalize(String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint penalize(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint reward(String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint reward(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint impact(String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint impact(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/tri/TriConstraintBuilderImpl.java | package ai.timefold.solver.constraint.streams.common.tri;
import java.util.Collection;
import java.util.Objects;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintBuilder;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintBuilder;
public final class TriConstraintBuilderImpl<A, B, C, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements TriConstraintBuilder<A, B, C, Score_> {
private QuadFunction<A, B, C, Score_, ConstraintJustification> justificationMapping;
private TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping;
public TriConstraintBuilderImpl(TriConstraintConstructor<A, B, C, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected QuadFunction<A, B, C, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> TriConstraintBuilder<A, B, C, Score_> justifyWith(
QuadFunction<A, B, C, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("Justification mapping already set (" + justificationMapping + ").");
}
this.justificationMapping =
(QuadFunction<A, B, C, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected TriFunction<A, B, C, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public TriConstraintBuilder<A, B, C, Score_> indictWith(TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("Indicted objects' mapping already set (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/uni/InnerUniConstraintStream.java | package ai.timefold.solver.constraint.streams.common.uni;
import java.math.BigDecimal;
import java.util.Collection;
import java.util.List;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import ai.timefold.solver.constraint.streams.common.RetrievalSemantics;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.constraint.streams.common.bi.BiJoinerComber;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintStream;
public interface InnerUniConstraintStream<A> extends UniConstraintStream<A> {
static <A> BiFunction<A, Score<?>, DefaultConstraintJustification> createDefaultJustificationMapping() {
return (a, score) -> DefaultConstraintJustification.of(score, a);
}
static <A> Function<A, Collection<?>> createDefaultIndictedObjectsMapping() {
return List::of;
}
RetrievalSemantics getRetrievalSemantics();
/**
* This method returns true if the constraint stream is guaranteed to only produce distinct tuples.
* See {@link #distinct()} for details.
*
* @return true if the guarantee of distinct tuples is provided
*/
boolean guaranteesDistinct();
@Override
default <B> BiConstraintStream<A, B> join(Class<B> otherClass, BiJoiner<A, B>... joiners) {
if (getRetrievalSemantics() == RetrievalSemantics.STANDARD) {
return join(getConstraintFactory().forEach(otherClass), joiners);
} else {
return join(getConstraintFactory().from(otherClass), joiners);
}
}
/**
* Allows {@link ConstraintFactory#forEachUniquePair(Class)} to reuse the joiner combing logic.
*
* @param otherStream never null
* @param joinerComber never null
* @param <B>
* @return never null
*/
<B> BiConstraintStream<A, B> join(UniConstraintStream<B> otherStream, BiJoinerComber<A, B> joinerComber);
@Override
default UniConstraintStream<A> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(Function.identity());
}
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> penalize(Score_ constraintWeight,
ToIntFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> penalizeLong(Score_ constraintWeight,
ToLongFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> penalizeBigDecimal(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default UniConstraintBuilder<A, ?> penalizeConfigurable(ToIntFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default UniConstraintBuilder<A, ?> penalizeConfigurableLong(ToLongFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default UniConstraintBuilder<A, ?> penalizeConfigurableBigDecimal(Function<A, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> reward(Score_ constraintWeight,
ToIntFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> rewardLong(Score_ constraintWeight,
ToLongFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> rewardBigDecimal(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default UniConstraintBuilder<A, ?> rewardConfigurable(ToIntFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default UniConstraintBuilder<A, ?> rewardConfigurableLong(ToLongFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default UniConstraintBuilder<A, ?> rewardConfigurableBigDecimal(Function<A, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> impact(Score_ constraintWeight,
ToIntFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> impactLong(Score_ constraintWeight,
ToLongFunction<A> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> impactBigDecimal(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default UniConstraintBuilder<A, ?> impactConfigurable(ToIntFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default UniConstraintBuilder<A, ?> impactConfigurableLong(ToLongFunction<A> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default UniConstraintBuilder<A, ?> impactConfigurableBigDecimal(Function<A, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToIntFunction<A> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
ToLongFunction<A> matchWeigher, ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> UniConstraintBuilder<A, Score_> innerImpact(Score_ constraintWeight,
Function<A, BigDecimal> matchWeigher, ScoreImpactType scoreImpactType);
@Override
default Constraint penalize(String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint penalize(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint penalizeConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint reward(String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint reward(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default Constraint rewardConfigurable(String constraintPackage, String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default Constraint impact(String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default Constraint impact(String constraintPackage, String constraintName, Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common | java-sources/ai/timefold/solver/timefold-solver-constraint-streams-common/0.9.39/ai/timefold/solver/constraint/streams/common/uni/UniConstraintBuilderImpl.java | package ai.timefold.solver.constraint.streams.common.uni;
import java.util.Collection;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.constraint.streams.common.AbstractConstraintBuilder;
import ai.timefold.solver.constraint.streams.common.ScoreImpactType;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintBuilder;
public final class UniConstraintBuilderImpl<A, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements UniConstraintBuilder<A, Score_> {
private BiFunction<A, Score_, ConstraintJustification> justificationMapping;
private Function<A, Collection<Object>> indictedObjectsMapping;
public UniConstraintBuilderImpl(UniConstraintConstructor<A, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected BiFunction<A, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> UniConstraintBuilder<A, Score_> justifyWith(
BiFunction<A, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("Justification mapping already set (" + justificationMapping + ").");
}
this.justificationMapping =
(BiFunction<A, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected Function<A, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public UniConstraintBuilder<A, Score_> indictWith(Function<A, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("Indicted objects' mapping already set (" + indictedObjectsMapping + ").");
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.