index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/FlattenLastTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class FlattenLastTriNode<A, B, C, NewC>
extends AbstractFlattenLastNode<TriTuple<A, B, C>, TriTuple<A, B, NewC>, C, NewC> {
private final int outputStoreSize;
public FlattenLastTriNode(int flattenLastStoreIndex, Function<C, Iterable<NewC>> mappingFunction,
TupleLifecycle<TriTuple<A, B, NewC>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, NewC> createTuple(TriTuple<A, B, C> originalTuple, NewC newC) {
return new TriTuple<>(originalTuple.factA, originalTuple.factB, newC, outputStoreSize);
}
@Override
protected C getEffectiveFactIn(TriTuple<A, B, C> tuple) {
return tuple.factC;
}
@Override
protected NewC getEffectiveFactOut(TriTuple<A, B, NewC> outTuple) {
return outTuple.factC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group0Mapping1CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class Group0Mapping1CollectorTriNode<OldA, OldB, OldC, A, ResultContainer_>
extends AbstractGroupTriNode<OldA, OldB, OldC, UniTuple<A>, Void, ResultContainer_, A> {
private final int outputStoreSize;
public Group0Mapping1CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainer_, A> collector,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, collector, nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected UniTuple<A> createOutTuple(Void groupKey) {
return new UniTuple<>(null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTuple<A> outTuple, A a) {
outTuple.factA = a;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group0Mapping2CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group0Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, OldC, A, B, ResultContainerA_, ResultContainerB_>
TriConstraintCollector<OldA, OldB, OldC, Object, Pair<A, B>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB) {
return (TriConstraintCollector<OldA, OldB, OldC, Object, Pair<A, B>>) ConstraintCollectors.compose(collectorA,
collectorB,
Pair::new);
}
@Override
protected BiTuple<A, B> createOutTuple(Void groupKey) {
return new BiTuple<>(null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, Pair<A, B> result) {
outTuple.factA = result.key();
outTuple.factB = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group0Mapping3CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group0Mapping3CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB, collectorC),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, OldC, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
TriConstraintCollector<OldA, OldB, OldC, Object, Triple<A, B, C>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC) {
return (TriConstraintCollector<OldA, OldB, OldC, Object, Triple<A, B, C>>) ConstraintCollectors.compose(collectorA,
collectorB, collectorC, Triple::new);
}
@Override
protected TriTuple<A, B, C> createOutTuple(Void groupKey) {
return new TriTuple<>(null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Triple<A, B, C> result) {
outTuple.factA = result.a();
outTuple.factB = result.b();
outTuple.factC = result.c();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group0Mapping4CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.score.stream.ConstraintCollectors;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Quadruple;
public final class Group0Mapping4CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorTriNode(int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB, collectorC, collectorD),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, OldB, OldC, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
TriConstraintCollector<OldA, OldB, OldC, Object, Quadruple<A, B, C, D>> mergeCollectors(
TriConstraintCollector<OldA, OldB, OldC, ResultContainerA_, A> collectorA,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD) {
return (TriConstraintCollector<OldA, OldB, OldC, Object, Quadruple<A, B, C, D>>) ConstraintCollectors.compose(
collectorA, collectorB, collectorC, collectorD, Quadruple::new);
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Void groupKey) {
return new QuadTuple<>(null, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Quadruple<A, B, C, D> result) {
outTuple.factA = result.a();
outTuple.factB = result.b();
outTuple.factC = result.c();
outTuple.factD = result.d();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group1Mapping0CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class Group1Mapping0CollectorTriNode<OldA, OldB, OldC, A>
extends AbstractGroupTriNode<OldA, OldB, OldC, UniTuple<A>, A, Void, Void> {
private final int outputStoreSize;
public Group1Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, OldA, OldB, OldC> A createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
TriTuple<OldA, OldB, OldC> tuple) {
return groupKeyMapping.apply(tuple.factA, tuple.factB, tuple.factC);
}
@Override
protected UniTuple<A> createOutTuple(A a) {
return new UniTuple<>(a, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTuple<A> aUniTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group1Mapping1CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
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.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class Group1Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, ResultContainer_>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainer_, B> collector,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> Group1Mapping0CollectorTriNode.createGroupKey(groupKeyMapping, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected BiTuple<A, B> createOutTuple(A a) {
return new BiTuple<>(a, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, B b) {
outTuple.factB = b;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group1Mapping2CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
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.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group1Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, A, Object, Pair<B, C>> {
private final int outputStoreSize;
public Group1Mapping2CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> Group1Mapping0CollectorTriNode.createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorTriNode.mergeCollectors(collectorB, collectorC), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(A a) {
return new TriTuple<>(a, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Pair<B, C> result) {
outTuple.factB = result.key();
outTuple.factC = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group1Mapping3CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group1Mapping3CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerB_, B> collectorB,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> Group1Mapping0CollectorTriNode.createGroupKey(groupKeyMapping, tuple),
Group0Mapping3CollectorTriNode.mergeCollectors(collectorB, collectorC, collectorD), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(A a) {
return new QuadTuple<>(a, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Triple<B, C, D> result) {
outTuple.factB = result.a();
outTuple.factC = result.b();
outTuple.factD = result.c();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group2Mapping0CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping0CollectorTriNode<OldA, OldB, OldC, A, B>
extends AbstractGroupTriNode<OldA, OldB, OldC, BiTuple<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, int groupStoreIndex,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, OldA, OldB, OldC> Pair<A, B> createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriTuple<OldA, OldB, OldC> tuple) {
OldA oldA = tuple.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
return new Pair<>(a, b);
}
@Override
protected BiTuple<A, B> createOutTuple(Pair<A, B> groupKey) {
return new BiTuple<>(groupKey.key(), groupKey.value(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group2Mapping1CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
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.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, C, ResultContainer_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, Pair<A, B>, ResultContainer_, C> {
private final int outputStoreSize;
public Group2Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainer_, C> collector,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> Group2Mapping0CollectorTriNode.createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(Pair<A, B> groupKey) {
return new TriTuple<>(groupKey.key(), groupKey.value(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, C c) {
outTuple.factC = c;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group2Mapping2CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping2CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerC_, C> collectorC,
TriConstraintCollector<OldA, OldB, OldC, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> Group2Mapping0CollectorTriNode.createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple),
Group0Mapping2CollectorTriNode.mergeCollectors(collectorC, collectorD), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Pair<A, B> groupKey) {
return new QuadTuple<>(groupKey.key(), groupKey.value(), null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Pair<C, D> result) {
outTuple.factC = result.key();
outTuple.factD = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group3Mapping0CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group3Mapping0CollectorTriNode<OldA, OldB, OldC, A, B, C>
extends AbstractGroupTriNode<OldA, OldB, OldC, TriTuple<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
int groupStoreIndex,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, C, OldA, OldB, OldC> Triple<A, B, C> createGroupKey(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriTuple<OldA, OldB, OldC> tuple) {
OldA oldA = tuple.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
C c = groupKeyMappingC.apply(oldA, oldB, oldC);
return new Triple<>(a, b, c);
}
@Override
protected TriTuple<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group3Mapping1CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import static ai.timefold.solver.core.impl.bavet.tri.Group3Mapping0CollectorTriNode.createGroupKey;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group3Mapping1CollectorTriNode<OldA, OldB, OldC, A, B, C, D, ResultContainer_>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Triple<A, B, C>, ResultContainer_, D> {
private final int outputStoreSize;
public Group3Mapping1CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
int groupStoreIndex, int undoStoreIndex,
TriConstraintCollector<OldA, OldB, OldC, ResultContainer_, D> collector,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Triple<A, B, C> groupKey) {
return new QuadTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, D d) {
outTuple.factD = d;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/Group4Mapping0CollectorTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Quadruple;
public final class Group4Mapping0CollectorTriNode<OldA, OldB, OldC, A, B, C, D>
extends
AbstractGroupTriNode<OldA, OldB, OldC, QuadTuple<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorTriNode(TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB, TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriFunction<OldA, OldB, OldC, D> groupKeyMappingD,
int groupStoreIndex,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, groupKeyMappingD, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <A, B, C, D, OldA, OldB, OldC> Quadruple<A, B, C, D> createGroupKey(
TriFunction<OldA, OldB, OldC, A> groupKeyMappingA,
TriFunction<OldA, OldB, OldC, B> groupKeyMappingB,
TriFunction<OldA, OldB, OldC, C> groupKeyMappingC,
TriFunction<OldA, OldB, OldC, D> groupKeyMappingD,
TriTuple<OldA, OldB, OldC> tuple) {
OldA oldA = tuple.factA;
OldB oldB = tuple.factB;
OldC oldC = tuple.factC;
A a = groupKeyMappingA.apply(oldA, oldB, oldC);
B b = groupKeyMappingB.apply(oldA, oldB, oldC);
C c = groupKeyMappingC.apply(oldA, oldB, oldC);
D d = groupKeyMappingD.apply(oldA, oldB, oldC);
return new Quadruple<>(a, b, c, d);
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), groupKey.d(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/IndexedIfExistsTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractIndexedIfExistsNode;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class IndexedIfExistsTriNode<A, B, C, D> extends AbstractIndexedIfExistsNode<TriTuple<A, B, C>, D> {
private final QuadPredicate<A, B, C, D> filtering;
public IndexedIfExistsTriNode(boolean shouldExist, IndexerFactory<D> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle) {
this(shouldExist, indexerFactory,
inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, -1,
inputStoreIndexRightKeys, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public IndexedIfExistsTriNode(boolean shouldExist, IndexerFactory<D> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, QuadPredicate<A, B, C, D> filtering) {
super(shouldExist, indexerFactory.buildTriLeftKeysExtractor(), indexerFactory,
inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightKeys, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, leftTuple.factC, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/IndexedJoinTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractIndexedJoinNode;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class IndexedJoinTriNode<A, B, C>
extends AbstractIndexedJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>> {
private final TriPredicate<A, B, C> filtering;
private final int outputStoreSize;
public IndexedJoinTriNode(IndexerFactory<C> indexerFactory,
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) {
super(indexerFactory.buildBiLeftKeysExtractor(), indexerFactory,
inputStoreIndexAB, inputStoreIndexEntryAB, inputStoreIndexOutTupleListAB,
inputStoreIndexC, inputStoreIndexEntryC, inputStoreIndexOutTupleListC,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexOutEntryAB, outputStoreIndexOutEntryC);
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, rightTuple.factA, outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(TriTuple<A, B, C> outTuple, BiTuple<A, B> leftTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
}
@Override
protected void setOutTupleRightFact(TriTuple<A, B, C> outTuple, UniTuple<C> rightTuple) {
outTuple.factC = rightTuple.factA;
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/MapTriToBiNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class MapTriToBiNode<A, B, C, NewA, NewB> extends AbstractMapNode<TriTuple<A, B, C>, BiTuple<NewA, NewB>> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
public MapTriToBiNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB,
TupleLifecycle<BiTuple<NewA, NewB>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
}
@Override
protected BiTuple<NewA, NewB> map(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new BiTuple<>(
mappingFunctionA.apply(factA, factB, factC),
mappingFunctionB.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, BiTuple<NewA, NewB> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunctionA.apply(factA, factB, factC);
NewB newB = mappingFunctionB.apply(factA, factB, factC);
outTuple.factA = newA;
outTuple.factB = newB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/MapTriToQuadNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class MapTriToQuadNode<A, B, C, NewA, NewB, NewC, NewD>
extends AbstractMapNode<TriTuple<A, B, C>, QuadTuple<NewA, NewB, NewC, NewD>> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private final TriFunction<A, B, C, NewC> mappingFunctionC;
private final TriFunction<A, B, C, NewD> mappingFunctionD;
public MapTriToQuadNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB, TriFunction<A, B, C, NewC> mappingFunctionC,
TriFunction<A, B, C, NewD> mappingFunctionD,
TupleLifecycle<QuadTuple<NewA, NewB, NewC, NewD>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
this.mappingFunctionC = Objects.requireNonNull(mappingFunctionC);
this.mappingFunctionD = Objects.requireNonNull(mappingFunctionD);
}
@Override
protected QuadTuple<NewA, NewB, NewC, NewD> map(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new QuadTuple<>(
mappingFunctionA.apply(factA, factB, factC),
mappingFunctionB.apply(factA, factB, factC),
mappingFunctionC.apply(factA, factB, factC),
mappingFunctionD.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, QuadTuple<NewA, NewB, NewC, NewD> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunctionA.apply(factA, factB, factC);
NewB newB = mappingFunctionB.apply(factA, factB, factC);
NewC newC = mappingFunctionC.apply(factA, factB, factC);
NewD newD = mappingFunctionD.apply(factA, factB, factC);
outTuple.factA = newA;
outTuple.factB = newB;
outTuple.factC = newC;
outTuple.factD = newD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/MapTriToTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class MapTriToTriNode<A, B, C, NewA, NewB, NewC>
extends AbstractMapNode<TriTuple<A, B, C>, TriTuple<NewA, NewB, NewC>> {
private final TriFunction<A, B, C, NewA> mappingFunctionA;
private final TriFunction<A, B, C, NewB> mappingFunctionB;
private final TriFunction<A, B, C, NewC> mappingFunctionC;
public MapTriToTriNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunctionA,
TriFunction<A, B, C, NewB> mappingFunctionB,
TriFunction<A, B, C, NewC> mappingFunctionC, TupleLifecycle<TriTuple<NewA, NewB, NewC>> nextNodesTupleLifecycle,
int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
this.mappingFunctionC = Objects.requireNonNull(mappingFunctionC);
}
@Override
protected TriTuple<NewA, NewB, NewC> map(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new TriTuple<>(
mappingFunctionA.apply(factA, factB, factC),
mappingFunctionB.apply(factA, factB, factC),
mappingFunctionC.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, TriTuple<NewA, NewB, NewC> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunctionA.apply(factA, factB, factC);
NewB newB = mappingFunctionB.apply(factA, factB, factC);
NewC newC = mappingFunctionC.apply(factA, factB, factC);
outTuple.factA = newA;
outTuple.factB = newB;
outTuple.factC = newC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/MapTriToUniNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class MapTriToUniNode<A, B, C, NewA> extends AbstractMapNode<TriTuple<A, B, C>, UniTuple<NewA>> {
private final TriFunction<A, B, C, NewA> mappingFunction;
public MapTriToUniNode(int mapStoreIndex, TriFunction<A, B, C, NewA> mappingFunction,
TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
protected UniTuple<NewA> map(TriTuple<A, B, C> tuple) {
A factA = tuple.factA;
B factB = tuple.factB;
C factC = tuple.factC;
return new UniTuple<>(
mappingFunction.apply(factA, factB, factC),
outputStoreSize);
}
@Override
protected void remap(TriTuple<A, B, C> inTuple, UniTuple<NewA> outTuple) {
A factA = inTuple.factA;
B factB = inTuple.factB;
C factC = inTuple.factC;
NewA newA = mappingFunction.apply(factA, factB, factC);
outTuple.factA = newA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/UnindexedIfExistsTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractUnindexedIfExistsNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class UnindexedIfExistsTriNode<A, B, C, D> extends AbstractUnindexedIfExistsNode<TriTuple<A, B, C>, D> {
private final QuadPredicate<A, B, C, D> filtering;
public UnindexedIfExistsTriNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightEntry,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle) {
this(shouldExist,
inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public UnindexedIfExistsTriNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList, int inputStoreIndexRightEntry,
int inputStoreIndexRightTrackerList,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle,
QuadPredicate<A, B, C, D> filtering) {
super(shouldExist,
inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList, inputStoreIndexRightEntry,
inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(TriTuple<A, B, C> leftTuple, UniTuple<D> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, leftTuple.factC, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/UnindexedJoinTriNode.java | package ai.timefold.solver.core.impl.bavet.tri;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractUnindexedJoinNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class UnindexedJoinTriNode<A, B, C>
extends AbstractUnindexedJoinNode<BiTuple<A, B>, C, TriTuple<A, B, C>> {
private final TriPredicate<A, B, C> filtering;
private final int outputStoreSize;
public UnindexedJoinTriNode(
int inputStoreIndexLeftEntry, int inputStoreIndexLeftOutTupleList,
int inputStoreIndexRightEntry, int inputStoreIndexRightOutTupleList,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, TriPredicate<A, B, C> filtering,
int outputStoreSize,
int outputStoreIndexLeftOutEntry, int outputStoreIndexRightOutEntry) {
super(inputStoreIndexLeftEntry, inputStoreIndexLeftOutTupleList,
inputStoreIndexRightEntry, inputStoreIndexRightOutTupleList,
nextNodesTupleLifecycle, filtering != null,
outputStoreIndexLeftOutEntry, outputStoreIndexRightOutEntry);
this.filtering = filtering;
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return new TriTuple<>(leftTuple.factA, leftTuple.factB, rightTuple.factA, outputStoreSize);
}
@Override
protected void setOutTupleLeftFacts(TriTuple<A, B, C> outTuple, BiTuple<A, B> leftTuple) {
outTuple.factA = leftTuple.factA;
outTuple.factB = leftTuple.factB;
}
@Override
protected void setOutTupleRightFact(TriTuple<A, B, C> outTuple, UniTuple<C> rightTuple) {
outTuple.factC = rightTuple.factA;
}
@Override
protected boolean testFiltering(BiTuple<A, B> leftTuple, UniTuple<C> rightTuple) {
return filtering.test(leftTuple.factA, leftTuple.factB, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/joiner/DefaultTriJoiner.java | package ai.timefold.solver.core.impl.bavet.tri.joiner;
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.core.api.score.stream.tri.TriJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.AbstractJoiner;
import ai.timefold.solver.core.impl.bavet.common.joiner.JoinerType;
import org.jspecify.annotations.NonNull;
public final class 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 @NonNull DefaultTriJoiner<A, B, C> and(@NonNull 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 (o instanceof DefaultTriJoiner<?, ?, ?> other) {
return Arrays.equals(joinerTypes, other.joinerTypes)
&& Arrays.equals(leftMappings, other.leftMappings)
&& Arrays.equals(rightMappings, other.rightMappings);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(Arrays.hashCode(joinerTypes), Arrays.hashCode(leftMappings), Arrays.hashCode(rightMappings));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/joiner/FilteringTriJoiner.java | package ai.timefold.solver.core.impl.bavet.tri.joiner;
import java.util.Objects;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
import org.jspecify.annotations.NonNull;
public final class FilteringTriJoiner<A, B, C> implements TriJoiner<A, B, C> {
private final TriPredicate<A, B, C> filter;
public FilteringTriJoiner(TriPredicate<A, B, C> filter) {
this.filter = filter;
}
@Override
public @NonNull FilteringTriJoiner<A, B, C> and(@NonNull TriJoiner<A, B, C> otherJoiner) {
FilteringTriJoiner<A, B, C> castJoiner = (FilteringTriJoiner<A, B, C>) otherJoiner;
return new FilteringTriJoiner<>(filter.and(castJoiner.getFilter()));
}
public TriPredicate<A, B, C> getFilter() {
return filter;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (!(o instanceof FilteringTriJoiner)) {
return false;
}
FilteringTriJoiner<?, ?, ?> other = (FilteringTriJoiner<?, ?, ?>) o;
return Objects.equals(filter, other.filter);
}
@Override
public int hashCode() {
return Objects.hash(filter);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/tri/joiner/TriJoinerComber.java | package ai.timefold.solver.core.impl.bavet.tri.joiner;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
/**
* Combs an array of {@link TriJoiner} instances into a mergedJoiner and a mergedFiltering.
*
* @param <A>
* @param <B>
* @param <C>
*/
public final class TriJoinerComber<A, B, C> {
public static <A, B, C> TriJoinerComber<A, B, C> comb(TriJoiner<A, B, C>[] joiners) {
List<DefaultTriJoiner<A, B, C>> defaultJoinerList = new ArrayList<>(joiners.length);
List<TriPredicate<A, B, C>> filteringList = new ArrayList<>(joiners.length);
int indexOfFirstFilter = -1;
// Make sure all indexing joiners, if any, come before filtering joiners. This is necessary for performance.
for (int i = 0; i < joiners.length; i++) {
TriJoiner<A, B, C> joiner = joiners[i];
if (joiner instanceof FilteringTriJoiner) {
// From now on, only allow filtering joiners.
indexOfFirstFilter = i;
filteringList.add(((FilteringTriJoiner<A, B, C>) joiner).getFilter());
} else if (joiner instanceof DefaultTriJoiner) {
if (indexOfFirstFilter >= 0) {
throw new IllegalStateException("Indexing joiner (" + joiner + ") must not follow " +
"a filtering joiner (" + joiners[indexOfFirstFilter] + ").\n" +
"Maybe reorder the joiners such that filtering() joiners are later in the parameter list.");
}
defaultJoinerList.add((DefaultTriJoiner<A, B, C>) joiner);
} else {
throw new IllegalArgumentException("The joiner class (" + joiner.getClass() + ") is not supported.");
}
}
DefaultTriJoiner<A, B, C> mergedJoiner = DefaultTriJoiner.merge(defaultJoinerList);
TriPredicate<A, B, C> mergedFiltering = mergeFiltering(filteringList);
return new TriJoinerComber<>(mergedJoiner, mergedFiltering);
}
private static <A, B, C> TriPredicate<A, B, C> mergeFiltering(List<TriPredicate<A, B, C>> filteringList) {
if (filteringList.isEmpty()) {
return null;
}
switch (filteringList.size()) {
case 1:
return filteringList.get(0);
case 2:
return filteringList.get(0).and(filteringList.get(1));
default:
// Avoid predicate.and() when more than 2 predicates for debugging and potentially performance
return (A a, B b, C c) -> {
for (TriPredicate<A, B, C> predicate : filteringList) {
if (!predicate.test(a, b, c)) {
return false;
}
}
return true;
};
}
}
private final DefaultTriJoiner<A, B, C> mergedJoiner;
private final TriPredicate<A, B, C> mergedFiltering;
public TriJoinerComber(DefaultTriJoiner<A, B, C> mergedJoiner, TriPredicate<A, B, C> mergedFiltering) {
this.mergedJoiner = mergedJoiner;
this.mergedFiltering = mergedFiltering;
}
/**
* @return never null
*/
public DefaultTriJoiner<A, B, C> getMergedJoiner() {
return mergedJoiner;
}
/**
* @return null if not applicable
*/
public TriPredicate<A, B, C> getMergedFiltering() {
return mergedFiltering;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/AbstractForEachUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.IdentityHashMap;
import java.util.Map;
import ai.timefold.solver.core.impl.bavet.common.AbstractNode;
import ai.timefold.solver.core.impl.bavet.common.Propagator;
import ai.timefold.solver.core.impl.bavet.common.StaticPropagationQueue;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleState;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
/**
* Filtering nodes are expensive.
* Considering that most streams start with a nullity check on genuine planning variables,
* it makes sense to create a specialized version of the node for this case ({@link ForEachFilteredUniNode}),
* as opposed to forcing an extra filter node on the generic case ({@link ForEachUnfilteredUniNode}).
*
* @param <A>
*/
@NullMarked
public abstract sealed class AbstractForEachUniNode<A>
extends AbstractNode
permits ForEachFilteredUniNode, ForEachUnfilteredUniNode {
private final Class<A> forEachClass;
private final int outputStoreSize;
private final StaticPropagationQueue<UniTuple<A>> propagationQueue;
protected final Map<A, UniTuple<A>> tupleMap = new IdentityHashMap<>(1000);
protected AbstractForEachUniNode(Class<A> forEachClass, TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
int outputStoreSize) {
this.forEachClass = forEachClass;
this.outputStoreSize = outputStoreSize;
this.propagationQueue = new StaticPropagationQueue<>(nextNodesTupleLifecycle);
}
public void insert(@Nullable A a) {
var tuple = new UniTuple<>(a, outputStoreSize);
var old = tupleMap.put(a, tuple);
if (old != null) {
throw new IllegalStateException("The fact (%s) was already inserted, so it cannot insert again."
.formatted(a));
}
propagationQueue.insert(tuple);
}
public abstract void update(@Nullable A a);
protected final void updateExisting(@Nullable A a, UniTuple<A> tuple) {
var state = tuple.state;
if (state.isDirty()) {
if (state == TupleState.DYING || state == TupleState.ABORTING) {
throw new IllegalStateException("The fact (%s) was retracted, so it cannot update."
.formatted(a));
}
// CREATING or UPDATING is ignored; it's already in the queue.
} else {
propagationQueue.update(tuple);
}
}
public void retract(@Nullable A a) {
var tuple = tupleMap.remove(a);
if (tuple == null) {
throw new IllegalStateException("The fact (%s) was never inserted, so it cannot retract."
.formatted(a));
}
retractExisting(a, tuple);
}
protected void retractExisting(@Nullable A a, UniTuple<A> tuple) {
var state = tuple.state;
if (state.isDirty()) {
if (state == TupleState.DYING || state == TupleState.ABORTING) {
throw new IllegalStateException("The fact (%s) was already retracted, so it cannot retract."
.formatted(a));
}
propagationQueue.retract(tuple, state == TupleState.CREATING ? TupleState.ABORTING : TupleState.DYING);
} else {
propagationQueue.retract(tuple, TupleState.DYING);
}
}
@Override
public Propagator getPropagator() {
return propagationQueue;
}
public final Class<A> getForEachClass() {
return forEachClass;
}
/**
* Determines if this node supports the given lifecycle operation.
* Unsupported nodes will not be called during that lifecycle operation.
*
* @param lifecycleOperation the lifecycle operation to check
* @return {@code true} if the given lifecycle operation is supported; otherwise, {@code false}.
*/
public abstract boolean supports(LifecycleOperation lifecycleOperation);
@Override
public final String toString() {
return "%s(%s)"
.formatted(getClass().getSimpleName(), forEachClass.getSimpleName());
}
/**
* Represents the various lifecycle operations that can be performed
* on tuples within a node in Bavet.
*/
public enum LifecycleOperation {
/**
* Represents the operation of inserting a new tuple into the node.
* This operation is typically performed when a new fact is added to the working solution
* and needs to be propagated through the node network.
*/
INSERT,
/**
* Represents the operation of updating an existing tuple within the node.
* This operation is typically triggered when a fact in the working solution
* is modified, requiring the corresponding tuple to be updated and its changes
* propagated through the node network.
*/
UPDATE,
/**
* Represents the operation of retracting or removing an existing tuple from the node.
* This operation is typically used when a fact is removed from the working solution
* and its corresponding tuple needs to be removed from the node network.
*/
RETRACT
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/AbstractGroupUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.BiFunction;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.AbstractGroupNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.AbstractTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
abstract class AbstractGroupUniNode<OldA, OutTuple_ extends AbstractTuple, GroupKey_, ResultContainer_, Result_>
extends AbstractGroupNode<UniTuple<OldA>, OutTuple_, GroupKey_, ResultContainer_, Result_> {
private final BiFunction<ResultContainer_, OldA, Runnable> accumulator;
protected AbstractGroupUniNode(int groupStoreIndex, int undoStoreIndex,
Function<UniTuple<OldA>, GroupKey_> groupKeyFunction,
UniConstraintCollector<OldA, ResultContainer_, Result_> collector,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
groupKeyFunction,
collector == null ? null : collector.supplier(),
collector == null ? null : collector.finisher(),
nextNodesTupleLifecycle, environmentMode);
accumulator = collector == null ? null : collector.accumulator();
}
protected AbstractGroupUniNode(int groupStoreIndex,
Function<UniTuple<OldA>, GroupKey_> groupKeyFunction,
TupleLifecycle<OutTuple_> nextNodesTupleLifecycle, EnvironmentMode environmentMode) {
super(groupStoreIndex,
groupKeyFunction, nextNodesTupleLifecycle, environmentMode);
accumulator = null;
}
@Override
protected final Runnable accumulate(ResultContainer_ resultContainer, UniTuple<OldA> tuple) {
return accumulator.apply(resultContainer, tuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/ConcatUniUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import ai.timefold.solver.core.impl.bavet.common.AbstractConcatNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class ConcatUniUniNode<A>
extends AbstractConcatNode<UniTuple<A>, UniTuple<A>, UniTuple<A>> {
public ConcatUniUniNode(TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
int inputStoreIndexLeftOutTupleList, int inputStoreIndexRightOutTupleList,
int outputStoreSize) {
super(nextNodesTupleLifecycle, inputStoreIndexLeftOutTupleList, inputStoreIndexRightOutTupleList,
outputStoreSize);
}
@Override
protected UniTuple<A> getOutTupleFromLeft(UniTuple<A> leftTuple) {
return new UniTuple<>(leftTuple.factA, outputStoreSize);
}
@Override
protected UniTuple<A> getOutTupleFromRight(UniTuple<A> rightTuple) {
return new UniTuple<>(rightTuple.factA, outputStoreSize);
}
@Override
protected void updateOutTupleFromLeft(UniTuple<A> leftTuple, UniTuple<A> outTuple) {
outTuple.factA = leftTuple.factA;
}
@Override
protected void updateOutTupleFromRight(UniTuple<A> rightTuple, UniTuple<A> outTuple) {
outTuple.factA = rightTuple.factA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/FlattenLastUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractFlattenLastNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class FlattenLastUniNode<A, NewA> extends AbstractFlattenLastNode<UniTuple<A>, UniTuple<NewA>, A, NewA> {
private final int outputStoreSize;
public FlattenLastUniNode(int flattenLastStoreIndex, Function<A, Iterable<NewA>> mappingFunction,
TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle, int outputStoreSize) {
super(flattenLastStoreIndex, mappingFunction, nextNodesTupleLifecycle);
this.outputStoreSize = outputStoreSize;
}
@Override
protected UniTuple<NewA> createTuple(UniTuple<A> originalTuple, NewA item) {
return new UniTuple<>(item, outputStoreSize);
}
@Override
protected A getEffectiveFactIn(UniTuple<A> tuple) {
return tuple.factA;
}
@Override
protected NewA getEffectiveFactOut(UniTuple<NewA> outTuple) {
return outTuple.factA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/ForEachFilteredUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.Objects;
import java.util.function.Predicate;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class ForEachFilteredUniNode<A>
extends AbstractForEachUniNode<A> {
private final Predicate<A> filter;
public ForEachFilteredUniNode(Class<A> forEachClass, Predicate<A> filter,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize) {
super(forEachClass, nextNodesTupleLifecycle, outputStoreSize);
this.filter = Objects.requireNonNull(filter);
}
@Override
public void insert(@Nullable A a) {
if (!filter.test(a)) { // Skip inserting the tuple as it does not pass the filter.
return;
}
super.insert(a);
}
@Override
public void update(@Nullable A a) {
var tuple = tupleMap.get(a);
if (tuple == null) { // The tuple was never inserted because it did not pass the filter.
insert(a);
} else if (filter.test(a)) {
updateExisting(a, tuple);
} else { // Tuple no longer passes the filter.
retract(a);
}
}
@Override
public void retract(@Nullable A a) {
var tuple = tupleMap.remove(a);
if (tuple == null) { // The tuple was never inserted because it did not pass the filter.
return;
}
super.retractExisting(a, tuple);
}
@Override
public boolean supports(LifecycleOperation lifecycleOperation) {
return true;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/ForEachUnfilteredUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public final class ForEachUnfilteredUniNode<A>
extends AbstractForEachUniNode<A> {
public ForEachUnfilteredUniNode(Class<A> forEachClass, TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
int outputStoreSize) {
super(forEachClass, nextNodesTupleLifecycle, outputStoreSize);
}
@Override
public void update(@Nullable A a) {
var tuple = tupleMap.get(a);
if (tuple == null) {
throw new IllegalStateException("The fact (%s) was never inserted, so it cannot update."
.formatted(a));
}
updateExisting(a, tuple);
}
@Override
public boolean supports(LifecycleOperation lifecycleOperation) {
return true;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group0Mapping1CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class Group0Mapping1CollectorUniNode<OldA, A, ResultContainer_>
extends AbstractGroupUniNode<OldA, UniTuple<A>, Void, ResultContainer_, A> {
private final int outputStoreSize;
public Group0Mapping1CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainer_, A> collector,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, collector, nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected UniTuple<A> createOutTuple(Void groupKey) {
return new UniTuple<>(null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTuple<A> outTuple, A a) {
outTuple.factA = a;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group0Mapping2CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
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.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group0Mapping2CollectorUniNode<OldA, A, B, ResultContainerA_, ResultContainerB_>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, Void, Object, Pair<A, B>> {
private final int outputStoreSize;
public Group0Mapping2CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, A, B, ResultContainerA_, ResultContainerB_>
UniConstraintCollector<OldA, Object, Pair<A, B>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB) {
return (UniConstraintCollector<OldA, Object, Pair<A, B>>) ConstraintCollectors.compose(collectorA, collectorB,
Pair::new);
}
@Override
protected BiTuple<A, B> createOutTuple(Void groupKey) {
return new BiTuple<>(null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, Pair<A, B> result) {
outTuple.factA = result.key();
outTuple.factB = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group0Mapping3CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
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.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group0Mapping3CollectorUniNode<OldA, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, Void, Object, Triple<A, B, C>> {
private final int outputStoreSize;
public Group0Mapping3CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB, collectorC),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <OldA, A, B, C, ResultContainerA_, ResultContainerB_, ResultContainerC_>
UniConstraintCollector<OldA, Object, Triple<A, B, C>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC) {
return (UniConstraintCollector<OldA, Object, Triple<A, B, C>>) ConstraintCollectors.compose(collectorA, collectorB,
collectorC, Triple::new);
}
@Override
protected TriTuple<A, B, C> createOutTuple(Void groupKey) {
return new TriTuple<>(null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Triple<A, B, C> result) {
outTuple.factA = result.a();
outTuple.factB = result.b();
outTuple.factC = result.c();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group0Mapping4CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
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.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Quadruple;
public final class Group0Mapping4CollectorUniNode<OldA, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Void, Object, Quadruple<A, B, C, D>> {
private final int outputStoreSize;
public Group0Mapping4CollectorUniNode(int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
null, mergeCollectors(collectorA, collectorB, collectorC, collectorD),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <OldA, A, B, C, D, ResultContainerA_, ResultContainerB_, ResultContainerC_, ResultContainerD_>
UniConstraintCollector<OldA, Object, Quadruple<A, B, C, D>> mergeCollectors(
UniConstraintCollector<OldA, ResultContainerA_, A> collectorA,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD) {
return (UniConstraintCollector<OldA, Object, Quadruple<A, B, C, D>>) ConstraintCollectors.compose(collectorA,
collectorB, collectorC, collectorD, Quadruple::new);
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Void groupKey) {
return new QuadTuple<>(null, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Quadruple<A, B, C, D> result) {
outTuple.factA = result.a();
outTuple.factB = result.b();
outTuple.factC = result.c();
outTuple.factD = result.d();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group1Mapping0CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class Group1Mapping0CollectorUniNode<OldA, A>
extends AbstractGroupUniNode<OldA, UniTuple<A>, A, Void, Void> {
private final int outputStoreSize;
public Group1Mapping0CollectorUniNode(Function<OldA, A> groupKeyMapping,
int groupStoreIndex,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, OldA> A createGroupKey(Function<OldA, A> groupKeyMapping, UniTuple<OldA> tuple) {
return groupKeyMapping.apply(tuple.factA);
}
@Override
protected UniTuple<A> createOutTuple(A a) {
return new UniTuple<>(a, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(UniTuple<A> aUniTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group1Mapping1CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import static ai.timefold.solver.core.impl.bavet.uni.Group1Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
public final class Group1Mapping1CollectorUniNode<OldA, A, B, ResultContainer_>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, A, ResultContainer_, B> {
private final int outputStoreSize;
public Group1Mapping1CollectorUniNode(Function<OldA, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainer_, B> collector,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected BiTuple<A, B> createOutTuple(A a) {
return new BiTuple<>(a, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, B b) {
outTuple.factB = b;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group1Mapping2CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group1Mapping2CollectorUniNode<OldA, A, B, C, ResultContainerB_, ResultContainerC_>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, A, Object, Pair<B, C>> {
private final int outputStoreSize;
public Group1Mapping2CollectorUniNode(Function<OldA, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> Group1Mapping0CollectorUniNode.createGroupKey(groupKeyMapping, tuple),
Group0Mapping2CollectorUniNode.mergeCollectors(collectorB, collectorC), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(A a) {
return new TriTuple<>(a, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Pair<B, C> result) {
outTuple.factB = result.key();
outTuple.factC = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group1Mapping3CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import static ai.timefold.solver.core.impl.bavet.uni.Group1Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group1Mapping3CollectorUniNode<OldA, A, B, C, D, ResultContainerB_, ResultContainerC_, ResultContainerD_>
extends AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, A, Object, Triple<B, C, D>> {
private final int outputStoreSize;
public Group1Mapping3CollectorUniNode(Function<OldA, A> groupKeyMapping,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerB_, B> collectorB,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMapping, tuple),
Group0Mapping3CollectorUniNode.mergeCollectors(collectorB, collectorC, collectorD), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(A a) {
return new QuadTuple<>(a, null, null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Triple<B, C, D> result) {
outTuple.factB = result.a();
outTuple.factC = result.b();
outTuple.factD = result.c();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group2Mapping0CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping0CollectorUniNode<OldA, A, B>
extends AbstractGroupUniNode<OldA, BiTuple<A, B>, Pair<A, B>, Void, Void> {
private final int outputStoreSize;
public Group2Mapping0CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
int groupStoreIndex,
TupleLifecycle<BiTuple<A, B>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, OldA> Pair<A, B> createGroupKey(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
UniTuple<OldA> tuple) {
OldA oldA = tuple.factA;
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
return new Pair<>(a, b);
}
@Override
protected BiTuple<A, B> createOutTuple(Pair<A, B> groupKey) {
return new BiTuple<>(groupKey.key(), groupKey.value(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(BiTuple<A, B> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group2Mapping1CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import static ai.timefold.solver.core.impl.bavet.uni.Group2Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping1CollectorUniNode<OldA, A, B, C, ResultContainer_>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, Pair<A, B>, ResultContainer_, C> {
private final int outputStoreSize;
public Group2Mapping1CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainer_, C> collector,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected TriTuple<A, B, C> createOutTuple(Pair<A, B> groupKey) {
return new TriTuple<>(groupKey.key(), groupKey.value(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, C c) {
outTuple.factC = c;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group2Mapping2CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import static ai.timefold.solver.core.impl.bavet.uni.Group2Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Pair;
public final class Group2Mapping2CollectorUniNode<OldA, A, B, C, D, ResultContainerC_, ResultContainerD_>
extends AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Pair<A, B>, Object, Pair<C, D>> {
private final int outputStoreSize;
public Group2Mapping2CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainerC_, C> collectorC,
UniConstraintCollector<OldA, ResultContainerD_, D> collectorD,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, tuple),
Group0Mapping2CollectorUniNode.mergeCollectors(collectorC, collectorD), nextNodesTupleLifecycle,
environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Pair<A, B> groupKey) {
return new QuadTuple<>(groupKey.key(), groupKey.value(), null, null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Pair<C, D> result) {
outTuple.factC = result.key();
outTuple.factD = result.value();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group3Mapping0CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group3Mapping0CollectorUniNode<OldA, A, B, C>
extends AbstractGroupUniNode<OldA, TriTuple<A, B, C>, Triple<A, B, C>, Void, Void> {
private final int outputStoreSize;
public Group3Mapping0CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
Function<OldA, C> groupKeyMappingC, int groupStoreIndex,
TupleLifecycle<TriTuple<A, B, C>> nextNodesTupleLifecycle, int outputStoreSize, EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
static <A, B, C, OldA> Triple<A, B, C> createGroupKey(Function<OldA, A> groupKeyMappingA,
Function<OldA, B> groupKeyMappingB, Function<OldA, C> groupKeyMappingC, UniTuple<OldA> tuple) {
OldA oldA = tuple.factA;
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
C c = groupKeyMappingC.apply(oldA);
return new Triple<>(a, b, c);
}
@Override
protected TriTuple<A, B, C> createOutTuple(Triple<A, B, C> groupKey) {
return new TriTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(TriTuple<A, B, C> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group3Mapping1CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import static ai.timefold.solver.core.impl.bavet.uni.Group3Mapping0CollectorUniNode.createGroupKey;
import java.util.function.Function;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.util.Triple;
public final class Group3Mapping1CollectorUniNode<OldA, A, B, C, D, ResultContainer_>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Triple<A, B, C>, ResultContainer_, D> {
private final int outputStoreSize;
public Group3Mapping1CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
Function<OldA, C> groupKeyMappingC,
int groupStoreIndex, int undoStoreIndex,
UniConstraintCollector<OldA, ResultContainer_, D> collector,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex, undoStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, tuple), collector,
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Triple<A, B, C> groupKey) {
return new QuadTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), null, outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, D d) {
outTuple.factD = d;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/Group4Mapping0CollectorUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.Function;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
import ai.timefold.solver.core.impl.util.Quadruple;
public final class Group4Mapping0CollectorUniNode<OldA, A, B, C, D>
extends
AbstractGroupUniNode<OldA, QuadTuple<A, B, C, D>, Quadruple<A, B, C, D>, Void, Void> {
private final int outputStoreSize;
public Group4Mapping0CollectorUniNode(Function<OldA, A> groupKeyMappingA, Function<OldA, B> groupKeyMappingB,
Function<OldA, C> groupKeyMappingC, Function<OldA, D> groupKeyMappingD,
int groupStoreIndex,
TupleLifecycle<QuadTuple<A, B, C, D>> nextNodesTupleLifecycle, int outputStoreSize,
EnvironmentMode environmentMode) {
super(groupStoreIndex,
tuple -> createGroupKey(groupKeyMappingA, groupKeyMappingB, groupKeyMappingC, groupKeyMappingD, tuple),
nextNodesTupleLifecycle, environmentMode);
this.outputStoreSize = outputStoreSize;
}
private static <A, B, C, D, OldA> Quadruple<A, B, C, D> createGroupKey(Function<OldA, A> groupKeyMappingA,
Function<OldA, B> groupKeyMappingB, Function<OldA, C> groupKeyMappingC, Function<OldA, D> groupKeyMappingD,
UniTuple<OldA> tuple) {
OldA oldA = tuple.factA;
A a = groupKeyMappingA.apply(oldA);
B b = groupKeyMappingB.apply(oldA);
C c = groupKeyMappingC.apply(oldA);
D d = groupKeyMappingD.apply(oldA);
return new Quadruple<>(a, b, c, d);
}
@Override
protected QuadTuple<A, B, C, D> createOutTuple(Quadruple<A, B, C, D> groupKey) {
return new QuadTuple<>(groupKey.a(), groupKey.b(), groupKey.c(), groupKey.d(), outputStoreSize);
}
@Override
protected void updateOutTupleToResult(QuadTuple<A, B, C, D> outTuple, Void unused) {
throw new IllegalStateException("Impossible state: collector is null.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/IndexedIfExistsUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractIndexedIfExistsNode;
import ai.timefold.solver.core.impl.bavet.common.index.IndexerFactory;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class IndexedIfExistsUniNode<A, B> extends AbstractIndexedIfExistsNode<UniTuple<A>, B> {
private final BiPredicate<A, B> filtering;
public IndexedIfExistsUniNode(boolean shouldExist, IndexerFactory<B> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle) {
this(shouldExist, indexerFactory,
inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, -1,
inputStoreIndexRightKeys, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public IndexedIfExistsUniNode(boolean shouldExist, IndexerFactory<B> indexerFactory,
int inputStoreIndexLeftKeys, int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList,
int inputStoreIndexRightKeys, int inputStoreIndexRightEntry, int inputStoreIndexRightTrackerList,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle, BiPredicate<A, B> filtering) {
super(shouldExist, indexerFactory.buildUniLeftKeysExtractor(), indexerFactory,
inputStoreIndexLeftKeys, inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList,
inputStoreIndexRightKeys, inputStoreIndexRightEntry, inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return filtering.test(leftTuple.factA, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/MapUniToBiNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.BiTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class MapUniToBiNode<A, NewA, NewB> extends AbstractMapNode<UniTuple<A>, BiTuple<NewA, NewB>> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
public MapUniToBiNode(int mapStoreIndex, Function<A, NewA> mappingFunctionA, Function<A, NewB> mappingFunctionB,
TupleLifecycle<BiTuple<NewA, NewB>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
}
@Override
protected BiTuple<NewA, NewB> map(UniTuple<A> tuple) {
A factA = tuple.factA;
return new BiTuple<>(
mappingFunctionA.apply(factA),
mappingFunctionB.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, BiTuple<NewA, NewB> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunctionA.apply(factA);
NewB newB = mappingFunctionB.apply(factA);
outTuple.factA = newA;
outTuple.factB = newB;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/MapUniToQuadNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.QuadTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class MapUniToQuadNode<A, NewA, NewB, NewC, NewD>
extends AbstractMapNode<UniTuple<A>, QuadTuple<NewA, NewB, NewC, NewD>> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
private final Function<A, NewD> mappingFunctionD;
public MapUniToQuadNode(int mapStoreIndex, Function<A, NewA> mappingFunctionA, Function<A, NewB> mappingFunctionB,
Function<A, NewC> mappingFunctionC, Function<A, NewD> mappingFunctionD,
TupleLifecycle<QuadTuple<NewA, NewB, NewC, NewD>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
this.mappingFunctionC = Objects.requireNonNull(mappingFunctionC);
this.mappingFunctionD = Objects.requireNonNull(mappingFunctionD);
}
@Override
protected QuadTuple<NewA, NewB, NewC, NewD> map(UniTuple<A> tuple) {
A factA = tuple.factA;
return new QuadTuple<>(
mappingFunctionA.apply(factA),
mappingFunctionB.apply(factA),
mappingFunctionC.apply(factA),
mappingFunctionD.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, QuadTuple<NewA, NewB, NewC, NewD> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunctionA.apply(factA);
NewB newB = mappingFunctionB.apply(factA);
NewC newC = mappingFunctionC.apply(factA);
NewD newD = mappingFunctionD.apply(factA);
outTuple.factA = newA;
outTuple.factB = newB;
outTuple.factC = newC;
outTuple.factD = newD;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/MapUniToTriNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TriTuple;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class MapUniToTriNode<A, NewA, NewB, NewC> extends AbstractMapNode<UniTuple<A>, TriTuple<NewA, NewB, NewC>> {
private final Function<A, NewA> mappingFunctionA;
private final Function<A, NewB> mappingFunctionB;
private final Function<A, NewC> mappingFunctionC;
public MapUniToTriNode(int mapStoreIndex, Function<A, NewA> mappingFunctionA, Function<A, NewB> mappingFunctionB,
Function<A, NewC> mappingFunctionC, TupleLifecycle<TriTuple<NewA, NewB, NewC>> nextNodesTupleLifecycle,
int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunctionA = Objects.requireNonNull(mappingFunctionA);
this.mappingFunctionB = Objects.requireNonNull(mappingFunctionB);
this.mappingFunctionC = Objects.requireNonNull(mappingFunctionC);
}
@Override
protected TriTuple<NewA, NewB, NewC> map(UniTuple<A> tuple) {
A factA = tuple.factA;
return new TriTuple<>(
mappingFunctionA.apply(factA),
mappingFunctionB.apply(factA),
mappingFunctionC.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, TriTuple<NewA, NewB, NewC> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunctionA.apply(factA);
NewB newB = mappingFunctionB.apply(factA);
NewC newC = mappingFunctionC.apply(factA);
outTuple.factA = newA;
outTuple.factB = newB;
outTuple.factC = newC;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/MapUniToUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.impl.bavet.common.AbstractMapNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class MapUniToUniNode<A, NewA> extends AbstractMapNode<UniTuple<A>, UniTuple<NewA>> {
private final Function<A, NewA> mappingFunction;
public MapUniToUniNode(int mapStoreIndex, Function<A, NewA> mappingFunction,
TupleLifecycle<UniTuple<NewA>> nextNodesTupleLifecycle, int outputStoreSize) {
super(mapStoreIndex, nextNodesTupleLifecycle, outputStoreSize);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
protected UniTuple<NewA> map(UniTuple<A> tuple) {
A factA = tuple.factA;
return new UniTuple<>(
mappingFunction.apply(factA),
outputStoreSize);
}
@Override
protected void remap(UniTuple<A> inTuple, UniTuple<NewA> outTuple) {
A factA = inTuple.factA;
NewA newA = mappingFunction.apply(factA);
outTuple.factA = newA;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/uni/UnindexedIfExistsUniNode.java | package ai.timefold.solver.core.impl.bavet.uni;
import java.util.function.BiPredicate;
import ai.timefold.solver.core.impl.bavet.common.AbstractUnindexedIfExistsNode;
import ai.timefold.solver.core.impl.bavet.common.tuple.TupleLifecycle;
import ai.timefold.solver.core.impl.bavet.common.tuple.UniTuple;
public final class UnindexedIfExistsUniNode<A, B> extends AbstractUnindexedIfExistsNode<UniTuple<A>, B> {
private final BiPredicate<A, B> filtering;
public UnindexedIfExistsUniNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexRightEntry,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle) {
this(shouldExist,
inputStoreIndexLeftCounterEntry, -1, inputStoreIndexRightEntry, -1,
nextNodesTupleLifecycle, null);
}
public UnindexedIfExistsUniNode(boolean shouldExist,
int inputStoreIndexLeftCounterEntry, int inputStoreIndexLeftTrackerList, int inputStoreIndexRightEntry,
int inputStoreIndexRightTrackerList,
TupleLifecycle<UniTuple<A>> nextNodesTupleLifecycle,
BiPredicate<A, B> filtering) {
super(shouldExist,
inputStoreIndexLeftCounterEntry, inputStoreIndexLeftTrackerList, inputStoreIndexRightEntry,
inputStoreIndexRightTrackerList,
nextNodesTupleLifecycle, filtering != null);
this.filtering = filtering;
}
@Override
protected boolean testFiltering(UniTuple<A> leftTuple, UniTuple<B> rightTuple) {
return filtering.test(leftTuple.factA, rightTuple.factA);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/visual/GraphEdge.java | package ai.timefold.solver.core.impl.bavet.visual;
import java.util.Objects;
import ai.timefold.solver.core.impl.bavet.common.AbstractNode;
record GraphEdge(AbstractNode from, AbstractNode to) {
@Override
public boolean equals(Object o) {
if (!(o instanceof GraphEdge graphEdge))
return false;
return Objects.equals(to.getId(), graphEdge.to.getId()) && Objects.equals(from.getId(), graphEdge.from.getId());
}
@Override
public int hashCode() {
return Objects.hash(from.getId(), to.getId());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/visual/GraphSink.java | package ai.timefold.solver.core.impl.bavet.visual;
import ai.timefold.solver.core.impl.bavet.common.AbstractNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
record GraphSink<Solution_>(AbstractNode node, BavetConstraint<Solution_> constraint) {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/bavet/visual/NodeGraph.java | package ai.timefold.solver.core.impl.bavet.visual;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.HashMap;
import java.util.LinkedHashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.Function;
import java.util.stream.Collectors;
import java.util.stream.Stream;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.bavet.common.AbstractNode;
import ai.timefold.solver.core.impl.bavet.common.AbstractTwoInputNode;
import ai.timefold.solver.core.impl.bavet.common.BavetAbstractConstraintStream;
import ai.timefold.solver.core.impl.bavet.common.BavetStream;
import ai.timefold.solver.core.impl.bavet.common.BavetStreamBinaryOperation;
import ai.timefold.solver.core.impl.bavet.uni.AbstractForEachUniNode;
import ai.timefold.solver.core.impl.score.stream.bavet.BavetConstraint;
import ai.timefold.solver.core.impl.score.stream.bavet.uni.BavetForEachUniConstraintStream;
public record NodeGraph<Solution_>(Solution_ solution, List<AbstractNode> sources,
List<GraphEdge> edges, List<GraphSink<Solution_>> sinks) {
@SuppressWarnings({ "unchecked", "rawtypes" })
public static <Solution_, Stream_ extends BavetStream> NodeGraph<Solution_> of(Solution_ solution,
List<AbstractNode> nodeList, Set<Constraint> constraintSet, Function<AbstractNode, Stream_> nodeToStreamFunction,
Function<Stream_, AbstractNode> streamToParentNodeFunction) {
var sourceList = new ArrayList<AbstractNode>();
var edgeList = new ArrayList<GraphEdge>();
for (var node : nodeList) {
var nodeCreator = nodeToStreamFunction.apply(node);
if (nodeCreator instanceof BavetForEachUniConstraintStream<?, ?>) {
sourceList.add(node);
} else if (nodeCreator instanceof BavetStreamBinaryOperation binaryOperation) {
var castBinaryOperation = (BavetStreamBinaryOperation<Stream_>) binaryOperation;
var leftParent = streamToParentNodeFunction.apply(castBinaryOperation.getLeftParent());
edgeList.add(new GraphEdge(leftParent, node));
var rightParent = streamToParentNodeFunction.apply(castBinaryOperation.getRightParent());
edgeList.add(new GraphEdge(rightParent, node));
} else {
var parent = streamToParentNodeFunction.apply(nodeCreator.getParent());
edgeList.add(new GraphEdge(parent, node));
}
}
var sinkList = new ArrayList<GraphSink<Solution_>>();
for (var constraint : constraintSet) {
var castConstraint = (BavetConstraint<Solution_>) constraint;
var stream = (BavetAbstractConstraintStream<Solution_>) castConstraint.getScoringConstraintStream();
var node = streamToParentNodeFunction.apply((Stream_) stream);
sinkList.add(new GraphSink<>(node, castConstraint));
}
return new NodeGraph<>(solution, sourceList.stream().distinct().toList(),
edgeList.stream().distinct().toList(),
sinkList.stream().distinct().toList());
}
public String buildGraphvizDOT() {
var stringBuilder = new StringBuilder();
var sourceStream = sources.stream();
var edgeStream = edges.stream().flatMap(edge -> Stream.of(edge.from(), edge.to()));
// Gather all known nodes and order them by their ID.
var allNodes = Stream.concat(sourceStream, edgeStream)
.distinct()
.sorted(Comparator.comparingLong(AbstractNode::getId))
.toList();
stringBuilder.append(
" label=<<B>Bavet Node Network for '%s'</B><BR />%d constraints, %d nodes>;%n"
.formatted(solution.toString(), sinks.size(), allNodes.size()));
// Specify the edges.
for (var node : allNodes) {
for (var edge : edges) {
if (edge.from().equals(node)) {
var line = " %s -> %s;%n".formatted(nodeId(node), nodeId(edge.to()));
stringBuilder.append(line);
}
}
}
for (var i = 0; i < sinks.size(); i++) {
var sink = sinks.get(i);
var line = " %s -> %s;%n".formatted(nodeId(sink.node()), constraintId(i));
stringBuilder.append(line);
}
// Specify visual attributes of the nodes.
for (var node : allNodes) {
var line = " %s %s;%n".formatted(nodeId(node), getMetadata(node));
stringBuilder.append(line);
}
for (var i = 0; i < sinks.size(); i++) {
var sink = sinks.get(i);
var line = " %s %s;%n".formatted(constraintId(i), getMetadata(sink, solution));
stringBuilder.append(line);
}
// Put nodes in the same layer to appear in the same rank.
var layerMap = new TreeMap<Long, Set<AbstractNode>>();
for (var node : allNodes) {
var layer = node.getLayerIndex();
layerMap.computeIfAbsent(layer, k -> new LinkedHashSet<>()).add(node);
}
for (var entry : layerMap.entrySet()) {
var line = entry.getValue().stream()
.map(NodeGraph::nodeId)
.collect(Collectors.joining("; ", " { rank=same; ", "; }" + System.lineSeparator()));
stringBuilder.append(line);
}
return """
digraph {
rankdir=LR;
%s}"""
.formatted(stringBuilder.toString());
}
private static String getMetadata(AbstractNode node) {
var metadata = getBaseDOTProperties("lightgrey", false);
if (node instanceof AbstractForEachUniNode<?>) {
metadata.put("style", "filled");
metadata.put("fillcolor", "#3e00ff");
metadata.put("fontcolor", "white");
} else if (node instanceof AbstractTwoInputNode<?, ?>) {
// Nodes that join get a different color.
metadata.put("style", "filled");
metadata.put("fillcolor", "#ff7700");
metadata.put("fontcolor", "white");
}
metadata.put("label", nodeLabel(node));
return mergeMetadata(metadata);
}
private static String mergeMetadata(Map<String, String> metadata) {
return metadata.entrySet().stream()
.map(entry -> {
if (entry.getKey().equals("label")) { // Labels are HTML-formatted.
return "%s=<%s>".formatted(entry.getKey(), entry.getValue());
} else {
return "%s=\"%s\"".formatted(entry.getKey(), entry.getValue());
}
})
.collect(Collectors.joining(", ", "[", "]"));
}
private static <Solution_> String getMetadata(GraphSink<Solution_> sink, Solution_ solution) {
var constraint = sink.constraint();
var metadata = getBaseDOTProperties("#3423a6", true);
metadata.put("label", "<B>%s</B><BR />(Weight: %s)"
.formatted(constraint.getConstraintRef().constraintName(), constraint.extractConstraintWeight(solution)));
return mergeMetadata(metadata);
}
private static Map<String, String> getBaseDOTProperties(String fillcolor, boolean whiteText) {
var metadata = new HashMap<String, String>();
metadata.put("shape", "plaintext");
metadata.put("pad", "0.2");
metadata.put("style", "filled");
metadata.put("fillcolor", fillcolor);
metadata.put("fontname", "Courier New");
metadata.put("fontcolor", whiteText ? "white" : "black");
return metadata;
}
private static String nodeId(AbstractNode node) {
return "node" + node.getId();
}
private static String constraintId(int id) {
return "impact" + id;
}
private static String nodeLabel(AbstractNode node) {
var className = node.getClass().getSimpleName()
.replace("Node", "");
if (node instanceof AbstractForEachUniNode<?> forEachNode) {
return "<B>%s</B><BR/>(%s)".formatted(className, forEachNode.getForEachClass().getSimpleName());
} else {
return "<B>%s</B>".formatted(className);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/ConstructionHeuristicPhase.java | package ai.timefold.solver.core.impl.constructionheuristic;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.phase.AbstractPhase;
import ai.timefold.solver.core.impl.phase.Phase;
import ai.timefold.solver.core.impl.phase.PossiblyInitializingPhase;
/**
* A {@link ConstructionHeuristicPhase} is a {@link Phase} which uses a construction heuristic algorithm,
* such as First Fit, First Fit Decreasing, Cheapest Insertion, ...
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see Phase
* @see AbstractPhase
* @see DefaultConstructionHeuristicPhase
*/
public interface ConstructionHeuristicPhase<Solution_>
extends PossiblyInitializingPhase<Solution_> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/DefaultConstructionHeuristicPhase.java | package ai.timefold.solver.core.impl.constructionheuristic;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.constructionheuristic.decider.ConstructionHeuristicDecider;
import ai.timefold.solver.core.impl.constructionheuristic.placer.EntityPlacer;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicPhaseScope;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicStepScope;
import ai.timefold.solver.core.impl.move.PlacerBasedMoveRepository;
import ai.timefold.solver.core.impl.phase.AbstractPossiblyInitializingPhase;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.impl.solver.termination.PhaseTermination;
import org.jspecify.annotations.NullMarked;
import org.slf4j.event.Level;
/**
* Default implementation of {@link ConstructionHeuristicPhase}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
@NullMarked
public class DefaultConstructionHeuristicPhase<Solution_>
extends AbstractPossiblyInitializingPhase<Solution_>
implements ConstructionHeuristicPhase<Solution_> {
protected final ConstructionHeuristicDecider<Solution_> decider;
protected final PlacerBasedMoveRepository<Solution_> moveRepository;
private TerminationStatus terminationStatus = TerminationStatus.NOT_TERMINATED;
protected DefaultConstructionHeuristicPhase(DefaultConstructionHeuristicPhaseBuilder<Solution_> builder) {
super(builder);
this.decider = builder.decider;
this.moveRepository = new PlacerBasedMoveRepository<>(builder.getEntityPlacer());
}
public EntityPlacer<Solution_> getEntityPlacer() {
return moveRepository.getPlacer();
}
@Override
public TerminationStatus getTerminationStatus() {
return terminationStatus;
}
@Override
public String getPhaseTypeString() {
return "Construction Heuristics";
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void solve(SolverScope<Solution_> solverScope) {
var phaseScope = buildPhaseScope(solverScope, phaseIndex);
phaseStarted(phaseScope);
var hasListVariable = moveRepository.hasListVariable();
var maxStepCount = -1;
if (hasListVariable) {
// In case of list variable with support for unassigned values, the placer will iterate indefinitely.
// (When it exhausts all values, it will start over from the beginning.)
// To prevent that, we need to limit the number of steps to the number of unassigned values.
// The use of ValueRangeManager is safe
// because it comes from the same score director as the working solution,
// and therefore is guaranteed to match.
// We compute fresh initialization statistics as opposed to possibly relying on a cached one,
// as otherwise Ruin&Recreate doesn't work correctly with its nested CH phase.
var scoreDirector = phaseScope.getScoreDirector();
var valueRangeManager = scoreDirector.getValueRangeManager();
maxStepCount = valueRangeManager.computeInitializationStatistics(scoreDirector.getWorkingSolution(), null)
.notInAnyListValueCount();
}
TerminationStatus earlyTerminationStatus = null;
while (moveRepository.hasNext()) {
var stepScope = new ConstructionHeuristicStepScope<>(phaseScope);
stepStarted(stepScope);
decider.decideNextStep(stepScope, moveRepository.iterator());
if (stepScope.getStep() == null) {
if (phaseTermination.isPhaseTerminated(phaseScope)) {
var logLevel = Level.TRACE;
if (decider.isLoggingEnabled() && logger.isEnabledForLevel(logLevel)) {
logger.atLevel(logLevel).log(
"{} Step index ({}), time spent ({}) terminated without picking a nextStep.",
logIndentation, stepScope.getStepIndex(),
stepScope.getPhaseScope().calculateSolverTimeMillisSpentUpToNow());
}
} else if (stepScope.getSelectedMoveCount() == 0L) {
var logLevel = Level.WARN;
if (decider.isLoggingEnabled() && logger.isEnabledForLevel(logLevel)) {
logger.atLevel(logLevel).log(
"{} No doable selected move at step index ({}), time spent ({}). Terminating phase early.",
logIndentation, stepScope.getStepIndex(),
stepScope.getPhaseScope().calculateSolverTimeMillisSpentUpToNow());
}
} else {
throw new IllegalStateException("The step index (" + stepScope.getStepIndex()
+ ") has selected move count (" + stepScope.getSelectedMoveCount()
+ ") but failed to pick a nextStep (" + stepScope.getStep() + ").");
}
// Although stepStarted has been called, stepEnded is not called for this step.
earlyTerminationStatus = TerminationStatus.early(phaseScope.getNextStepIndex());
break;
}
doStep(stepScope);
stepEnded(stepScope);
phaseScope.setLastCompletedStepScope(stepScope);
if (hasListVariable && stepScope.getStepIndex() >= maxStepCount) {
earlyTerminationStatus = TerminationStatus.regular(phaseScope.getNextStepIndex());
break;
} else if (phaseTermination.isPhaseTerminated(phaseScope)) {
earlyTerminationStatus = TerminationStatus.early(phaseScope.getNextStepIndex());
break;
}
}
// We only store the termination status, which is exposed to the outside, when the phase has ended.
terminationStatus = translateEarlyTermination(phaseScope, earlyTerminationStatus, moveRepository.hasNext());
phaseEnded(phaseScope);
}
protected ConstructionHeuristicPhaseScope<Solution_> buildPhaseScope(SolverScope<Solution_> solverScope, int phaseIndex) {
return new ConstructionHeuristicPhaseScope<>(solverScope, phaseIndex);
}
protected void doStep(ConstructionHeuristicStepScope<Solution_> stepScope) {
var step = stepScope.getStep();
stepScope.getScoreDirector().executeMove(step);
predictWorkingStepScore(stepScope, step);
if (!isNested()) {
processWorkingSolutionDuringStep(stepScope);
}
}
private void processWorkingSolutionDuringStep(ConstructionHeuristicStepScope<Solution_> stepScope) {
var solver = stepScope.getPhaseScope().getSolverScope().getSolver();
solver.getBestSolutionRecaller().processWorkingSolutionDuringConstructionHeuristicsStep(stepScope);
}
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
super.solvingStarted(solverScope);
moveRepository.solvingStarted(solverScope);
decider.solvingStarted(solverScope);
}
public void phaseStarted(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
super.phaseStarted(phaseScope);
terminationStatus = TerminationStatus.NOT_TERMINATED;
moveRepository.phaseStarted(phaseScope);
decider.phaseStarted(phaseScope);
}
public void stepStarted(ConstructionHeuristicStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
moveRepository.stepStarted(stepScope);
decider.stepStarted(stepScope);
}
public void stepEnded(ConstructionHeuristicStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
moveRepository.stepEnded(stepScope);
decider.stepEnded(stepScope);
if (decider.isLoggingEnabled() && logger.isDebugEnabled()) {
var timeMillisSpent = stepScope.getPhaseScope().calculateSolverTimeMillisSpentUpToNow();
logger.debug("{} CH step ({}), time spent ({}), score ({}), selected move count ({}), picked move ({}).",
logIndentation,
stepScope.getStepIndex(), timeMillisSpent,
stepScope.getScore().raw(),
stepScope.getSelectedMoveCount(),
stepScope.getStepString());
}
}
public void phaseEnded(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
super.phaseEnded(phaseScope);
ensureCorrectTermination(phaseScope, logger);
updateBestSolutionAndFire(phaseScope);
moveRepository.phaseEnded(phaseScope);
decider.phaseEnded(phaseScope);
phaseScope.endingNow();
if (decider.isLoggingEnabled() && logger.isInfoEnabled()) {
logger.info(
"{}Construction Heuristic phase ({}) ended: time spent ({}), best score ({}), move evaluation speed ({}/sec), step total ({}).",
logIndentation,
phaseIndex,
phaseScope.calculateSolverTimeMillisSpentUpToNow(),
phaseScope.getBestScore().raw(),
phaseScope.getPhaseMoveEvaluationSpeed(),
phaseScope.getNextStepIndex());
}
}
private void updateBestSolutionAndFire(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
if (!isNested() && !phaseScope.getStartingScore().equals(phaseScope.getBestScore())) {
// Only update the best solution if the CH made any change; nested phases don't update the best solution.
var solver = phaseScope.getSolverScope().getSolver();
solver.getBestSolutionRecaller().updateBestSolutionAndFire(phaseScope.getSolverScope());
}
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
super.solvingEnded(solverScope);
moveRepository.solvingEnded(solverScope);
decider.solvingEnded(solverScope);
}
@Override
public void solvingError(SolverScope<Solution_> solverScope, Exception exception) {
super.solvingError(solverScope, exception);
decider.solvingError(solverScope, exception);
}
public static class DefaultConstructionHeuristicPhaseBuilder<Solution_>
extends AbstractPossiblyInitializingPhaseBuilder<Solution_> {
private final EntityPlacer<Solution_> entityPlacer;
private final ConstructionHeuristicDecider<Solution_> decider;
public DefaultConstructionHeuristicPhaseBuilder(int phaseIndex, boolean lastInitializingPhase, String logIndentation,
PhaseTermination<Solution_> phaseTermination, EntityPlacer<Solution_> entityPlacer,
ConstructionHeuristicDecider<Solution_> decider) {
super(phaseIndex, lastInitializingPhase, logIndentation, phaseTermination);
this.entityPlacer = entityPlacer;
this.decider = decider;
}
@Override
public DefaultConstructionHeuristicPhaseBuilder<Solution_> enableAssertions(EnvironmentMode environmentMode) {
super.enableAssertions(environmentMode);
return this;
}
public EntityPlacer<Solution_> getEntityPlacer() {
return entityPlacer;
}
@Override
public DefaultConstructionHeuristicPhase<Solution_> build() {
return new DefaultConstructionHeuristicPhase<>(this);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/DefaultConstructionHeuristicPhaseFactory.java | package ai.timefold.solver.core.impl.constructionheuristic;
import java.util.Objects;
import java.util.Optional;
import ai.timefold.solver.core.config.constructionheuristic.ConstructionHeuristicPhaseConfig;
import ai.timefold.solver.core.config.constructionheuristic.ConstructionHeuristicType;
import ai.timefold.solver.core.config.constructionheuristic.decider.forager.ConstructionHeuristicForagerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.EntityPlacerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.PooledEntityPlacerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.QueuedEntityPlacerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.QueuedValuePlacerConfig;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionCacheType;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionOrder;
import ai.timefold.solver.core.config.heuristic.selector.move.MoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.composite.CartesianProductMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.composite.UnionMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.list.ListChangeMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.value.ValueSelectorConfig;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.enterprise.TimefoldSolverEnterpriseService;
import ai.timefold.solver.core.impl.constructionheuristic.DefaultConstructionHeuristicPhase.DefaultConstructionHeuristicPhaseBuilder;
import ai.timefold.solver.core.impl.constructionheuristic.decider.ConstructionHeuristicDecider;
import ai.timefold.solver.core.impl.constructionheuristic.decider.forager.ConstructionHeuristicForager;
import ai.timefold.solver.core.impl.constructionheuristic.decider.forager.ConstructionHeuristicForagerFactory;
import ai.timefold.solver.core.impl.constructionheuristic.placer.EntityPlacer;
import ai.timefold.solver.core.impl.constructionheuristic.placer.EntityPlacerFactory;
import ai.timefold.solver.core.impl.constructionheuristic.placer.PooledEntityPlacerFactory;
import ai.timefold.solver.core.impl.constructionheuristic.placer.QueuedEntityPlacerFactory;
import ai.timefold.solver.core.impl.constructionheuristic.placer.QueuedValuePlacerFactory;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.phase.AbstractPhaseFactory;
import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecaller;
import ai.timefold.solver.core.impl.solver.termination.PhaseTermination;
import ai.timefold.solver.core.impl.solver.termination.SolverTermination;
public class DefaultConstructionHeuristicPhaseFactory<Solution_>
extends AbstractPhaseFactory<Solution_, ConstructionHeuristicPhaseConfig> {
public DefaultConstructionHeuristicPhaseFactory(ConstructionHeuristicPhaseConfig phaseConfig) {
super(phaseConfig);
}
public final DefaultConstructionHeuristicPhaseBuilder<Solution_> getBuilder(int phaseIndex,
boolean lastInitializingPhase, HeuristicConfigPolicy<Solution_> solverConfigPolicy,
SolverTermination<Solution_> solverTermination) {
var constructionHeuristicType_ = Objects.requireNonNullElse(phaseConfig.getConstructionHeuristicType(),
ConstructionHeuristicType.ALLOCATE_ENTITY_FROM_QUEUE);
var entitySorterManner = Objects.requireNonNullElse(phaseConfig.getEntitySorterManner(),
constructionHeuristicType_.getDefaultEntitySorterManner());
var valueSorterManner = Objects.requireNonNullElse(phaseConfig.getValueSorterManner(),
constructionHeuristicType_.getDefaultValueSorterManner());
var phaseConfigPolicy = solverConfigPolicy.cloneBuilder()
.withReinitializeVariableFilterEnabled(true)
.withInitializedChainedValueFilterEnabled(true)
.withUnassignedValuesAllowed(true)
.withEntitySorterManner(entitySorterManner)
.withValueSorterManner(valueSorterManner)
.build();
var entityPlacerConfig_ = getValidEntityPlacerConfig()
.orElseGet(() -> buildDefaultEntityPlacerConfig(phaseConfigPolicy, constructionHeuristicType_));
var entityPlacer = EntityPlacerFactory.<Solution_> create(entityPlacerConfig_)
.buildEntityPlacer(phaseConfigPolicy);
return createBuilder(phaseConfigPolicy, solverTermination, phaseIndex, lastInitializingPhase, entityPlacer);
}
protected DefaultConstructionHeuristicPhaseBuilder<Solution_> createBuilder(
HeuristicConfigPolicy<Solution_> phaseConfigPolicy, SolverTermination<Solution_> solverTermination, int phaseIndex,
boolean lastInitializingPhase, EntityPlacer<Solution_> entityPlacer) {
var phaseTermination = buildPhaseTermination(phaseConfigPolicy, solverTermination);
return new DefaultConstructionHeuristicPhaseBuilder<>(phaseIndex, lastInitializingPhase,
phaseConfigPolicy.getLogIndentation(), phaseTermination, entityPlacer,
buildDecider(phaseConfigPolicy, phaseTermination))
.enableAssertions(phaseConfigPolicy.getEnvironmentMode());
}
@Override
public ConstructionHeuristicPhase<Solution_> buildPhase(int phaseIndex, boolean lastInitializingPhase,
HeuristicConfigPolicy<Solution_> solverConfigPolicy, BestSolutionRecaller<Solution_> bestSolutionRecaller,
SolverTermination<Solution_> solverTermination) {
return getBuilder(phaseIndex, lastInitializingPhase, solverConfigPolicy, solverTermination)
.build();
}
private Optional<EntityPlacerConfig<?>> getValidEntityPlacerConfig() {
var entityPlacerConfig = phaseConfig.getEntityPlacerConfig();
if (entityPlacerConfig == null) {
return Optional.empty();
}
if (phaseConfig.getConstructionHeuristicType() != null) {
throw new IllegalArgumentException(
"The constructionHeuristicType (%s) must not be configured if the entityPlacerConfig (%s) is explicitly configured."
.formatted(phaseConfig.getConstructionHeuristicType(), entityPlacerConfig));
}
var moveSelectorConfigList = phaseConfig.getMoveSelectorConfigList();
if (moveSelectorConfigList != null) {
throw new IllegalArgumentException(
"The moveSelectorConfigList (%s) cannot be configured if the entityPlacerConfig (%s) is explicitly configured."
.formatted(moveSelectorConfigList, entityPlacerConfig));
}
return Optional.of(entityPlacerConfig);
}
private EntityPlacerConfig<?> buildDefaultEntityPlacerConfig(HeuristicConfigPolicy<Solution_> configPolicy,
ConstructionHeuristicType constructionHeuristicType) {
return findValidListVariableDescriptor(configPolicy.getSolutionDescriptor())
.map(listVariableDescriptor -> buildListVariableQueuedValuePlacerConfig(configPolicy, listVariableDescriptor))
.orElseGet(() -> buildUnfoldedEntityPlacerConfig(configPolicy, constructionHeuristicType));
}
private Optional<ListVariableDescriptor<?>>
findValidListVariableDescriptor(SolutionDescriptor<Solution_> solutionDescriptor) {
var listVariableDescriptor = solutionDescriptor.getListVariableDescriptor();
if (listVariableDescriptor == null) {
return Optional.empty();
}
failIfConfigured(phaseConfig.getConstructionHeuristicType(), "constructionHeuristicType");
failIfConfigured(phaseConfig.getMoveSelectorConfigList(), "moveSelectorConfigList");
// When an entity has both list and basic variables,
// the CH configuration will require two separate placers to initialize each variable,
// which cannot be deduced automatically by default, since a single placer would be returned
if (listVariableDescriptor.getEntityDescriptor().hasAnyGenuineBasicVariables()) {
throw new IllegalArgumentException("""
The entity (%s) has both basic and list variables and cannot be deduced automatically.
Maybe customize the phase configuration and add separate construction heuristic phases for each variable."""
.formatted(listVariableDescriptor.getEntityDescriptor().getEntityClass()));
}
return Optional.of(listVariableDescriptor);
}
private static void failIfConfigured(Object configValue, String configName) {
if (configValue != null) {
throw new IllegalArgumentException("Construction Heuristic phase with a list variable does not support "
+ configName + " configuration. Remove the " + configName + " (" + configValue + ") from the config.");
}
}
@SuppressWarnings("rawtypes")
public static EntityPlacerConfig buildListVariableQueuedValuePlacerConfig(HeuristicConfigPolicy<?> configPolicy,
ListVariableDescriptor<?> variableDescriptor) {
var mimicSelectorId = variableDescriptor.getVariableName();
// Prepare recording ValueSelector config.
var mimicRecordingValueSelectorConfig = new ValueSelectorConfig(variableDescriptor.getVariableName())
.withId(mimicSelectorId);
if (ValueSelectorConfig.hasSorter(configPolicy.getValueSorterManner(), variableDescriptor)) {
mimicRecordingValueSelectorConfig = mimicRecordingValueSelectorConfig.withCacheType(SelectionCacheType.PHASE)
.withSelectionOrder(SelectionOrder.SORTED)
.withSorterManner(configPolicy.getValueSorterManner());
}
// Prepare replaying ValueSelector config.
var mimicReplayingValueSelectorConfig = new ValueSelectorConfig()
.withMimicSelectorRef(mimicSelectorId)
.withVariableName(variableDescriptor.getVariableName());
// ListChangeMoveSelector uses the replaying ValueSelector.
var listChangeMoveSelectorConfig = new ListChangeMoveSelectorConfig()
.withValueSelectorConfig(mimicReplayingValueSelectorConfig);
// Finally, QueuedValuePlacer uses the recording ValueSelector and a ListChangeMoveSelector.
// The ListChangeMoveSelector's replaying ValueSelector mimics the QueuedValuePlacer's recording ValueSelector.
return new QueuedValuePlacerConfig()
.withEntityClass(variableDescriptor.getEntityDescriptor().getEntityClass())
.withValueSelectorConfig(mimicRecordingValueSelectorConfig)
.withMoveSelectorConfig(listChangeMoveSelectorConfig);
}
protected ConstructionHeuristicDecider<Solution_> buildDecider(HeuristicConfigPolicy<Solution_> configPolicy,
PhaseTermination<Solution_> termination) {
var forager = buildForager(configPolicy);
var moveThreadCount = configPolicy.getMoveThreadCount();
var decider = (moveThreadCount == null)
? new ConstructionHeuristicDecider<>(configPolicy.getLogIndentation(), termination, forager)
: TimefoldSolverEnterpriseService.loadOrFail(TimefoldSolverEnterpriseService.Feature.MULTITHREADED_SOLVING)
.buildConstructionHeuristic(termination, forager, configPolicy);
decider.enableAssertions(configPolicy.getEnvironmentMode());
return decider;
}
protected ConstructionHeuristicForager<Solution_> buildForager(HeuristicConfigPolicy<Solution_> configPolicy) {
var foragerConfig_ =
Objects.requireNonNullElseGet(phaseConfig.getForagerConfig(), ConstructionHeuristicForagerConfig::new);
return ConstructionHeuristicForagerFactory.<Solution_> create(foragerConfig_).buildForager(configPolicy);
}
private EntityPlacerConfig<?> buildUnfoldedEntityPlacerConfig(HeuristicConfigPolicy<Solution_> phaseConfigPolicy,
ConstructionHeuristicType constructionHeuristicType) {
return switch (constructionHeuristicType) {
case FIRST_FIT, FIRST_FIT_DECREASING, WEAKEST_FIT, WEAKEST_FIT_DECREASING, STRONGEST_FIT, STRONGEST_FIT_DECREASING,
ALLOCATE_ENTITY_FROM_QUEUE -> {
if (!ConfigUtils.isEmptyCollection(phaseConfig.getMoveSelectorConfigList())) {
yield QueuedEntityPlacerFactory.unfoldNew(phaseConfigPolicy, phaseConfig.getMoveSelectorConfigList());
}
yield new QueuedEntityPlacerConfig();
}
case ALLOCATE_TO_VALUE_FROM_QUEUE -> {
if (!ConfigUtils.isEmptyCollection(phaseConfig.getMoveSelectorConfigList())) {
yield QueuedValuePlacerFactory.unfoldNew(checkSingleMoveSelectorConfig());
}
yield new QueuedValuePlacerConfig();
}
case CHEAPEST_INSERTION, ALLOCATE_FROM_POOL -> {
if (!ConfigUtils.isEmptyCollection(phaseConfig.getMoveSelectorConfigList())) {
yield PooledEntityPlacerFactory.unfoldNew(phaseConfigPolicy, checkSingleMoveSelectorConfig());
}
yield new PooledEntityPlacerConfig();
}
};
}
private MoveSelectorConfig<?> checkSingleMoveSelectorConfig() { // Non-null guaranteed by the caller.
var moveSelectorConfigList = Objects.requireNonNull(phaseConfig.getMoveSelectorConfigList());
if (moveSelectorConfigList.size() != 1) {
throw new IllegalArgumentException("""
For the constructionHeuristicType (%s), the moveSelectorConfigList (%s) must be a singleton.
Use a single %s or %s element to nest multiple MoveSelectors."""
.formatted(phaseConfig.getConstructionHeuristicType(), phaseConfig.getMoveSelectorConfigList(),
UnionMoveSelectorConfig.class.getSimpleName(),
CartesianProductMoveSelectorConfig.class.getSimpleName()));
}
return moveSelectorConfigList.get(0);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider/ConstructionHeuristicDecider.java | package ai.timefold.solver.core.impl.constructionheuristic.decider;
import java.util.Iterator;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.constructionheuristic.decider.forager.ConstructionHeuristicForager;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicMoveScope;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicPhaseScope;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicStepScope;
import ai.timefold.solver.core.impl.heuristic.move.LegacyMoveAdapter;
import ai.timefold.solver.core.impl.heuristic.move.NoChangeMove;
import ai.timefold.solver.core.impl.phase.scope.SolverLifecyclePoint;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.impl.solver.termination.PhaseTermination;
import ai.timefold.solver.core.preview.api.move.Move;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class ConstructionHeuristicDecider<Solution_> {
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
protected final String logIndentation;
protected final PhaseTermination<Solution_> termination;
protected final ConstructionHeuristicForager<Solution_> forager;
protected boolean assertMoveScoreFromScratch = false;
protected boolean assertExpectedUndoMoveScore = false;
public ConstructionHeuristicDecider(String logIndentation, PhaseTermination<Solution_> termination,
ConstructionHeuristicForager<Solution_> forager) {
this.logIndentation = logIndentation;
this.termination = termination;
this.forager = forager;
}
public boolean isLoggingEnabled() {
return true;
}
public ConstructionHeuristicForager<Solution_> getForager() {
return forager;
}
public void enableAssertions(EnvironmentMode environmentMode) {
this.assertMoveScoreFromScratch = environmentMode.isFullyAsserted();
this.assertExpectedUndoMoveScore = environmentMode.isIntrusivelyAsserted();
}
// ************************************************************************
// Worker methods
// ************************************************************************
public void solvingStarted(SolverScope<Solution_> solverScope) {
forager.solvingStarted(solverScope);
}
public void phaseStarted(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
forager.phaseStarted(phaseScope);
}
public void stepStarted(ConstructionHeuristicStepScope<Solution_> stepScope) {
forager.stepStarted(stepScope);
}
public void stepEnded(ConstructionHeuristicStepScope<Solution_> stepScope) {
forager.stepEnded(stepScope);
}
public void phaseEnded(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
forager.phaseEnded(phaseScope);
}
public void solvingEnded(SolverScope<Solution_> solverScope) {
forager.solvingEnded(solverScope);
}
public void solvingError(SolverScope<Solution_> solverScope, Exception exception) {
// Overridable by a subclass.
}
public void decideNextStep(ConstructionHeuristicStepScope<Solution_> stepScope, Iterator<Move<Solution_>> moveIterator) {
var moveIndex = 0;
var terminatedPrematurely = false;
while (moveIterator.hasNext()) {
var move = moveIterator.next();
var allowedNonDoableMove = isAllowedNonDoableMove(move);
if (!allowedNonDoableMove) {
var moveDirector = stepScope.getMoveDirector();
if (!LegacyMoveAdapter.isDoable(moveDirector, move)) {
// Construction Heuristic should not do non-doable moves, but in some cases, it has to.
// Specifically:
// 1/ NoChangeMove for list variable; means "try to not assign that value".
// 2/ ChangeMove for basic variable; move from null to null means "try to not assign that value".
// 3/ Technically also ChainedChangeMove, but chained doesn't support unassigned values.
// Every other non-doable move must not be executed, as it may cause all sorts of issues.
// Example: ListChangeMove from a[0] to a[1] when the list of 'a' only has 1 element.
// This move is correctly non-doable,
// but it may be generated by the placer, and must therefore be ignored.
// Note: CH will only ever see change moves, as its purpose is to assign a variable to a value.
// It will never do anything more complex than that.
continue;
}
}
var moveScope = new ConstructionHeuristicMoveScope<>(stepScope, moveIndex, move);
moveIndex++;
doMove(moveScope);
if (forager.isQuitEarly()) {
break;
}
stepScope.getPhaseScope().getSolverScope().checkYielding();
if (termination.isPhaseTerminated(stepScope.getPhaseScope())) {
terminatedPrematurely = true;
break;
}
}
// Only pick a move when CH has finished all moves within the step, or when pick early was enabled.
// If CH terminated prematurely, it means a move could have been picked which makes the solution worse,
// while there were moves still to be evaluated that could have been better.
// This typically happens for list variable with allowsUnassignedValues=true,
// where most moves make the score worse and the only move that doesn't is the move which assigns null.
// This move typically comes last, and therefore if the phase terminates early, it will not be attempted.
if (!terminatedPrematurely) {
pickMove(stepScope);
}
}
private static <Solution_> boolean isAllowedNonDoableMove(Move<Solution_> move) {
if (move instanceof LegacyMoveAdapter<Solution_> legacyMove) {
var adaptedMove = legacyMove.legacyMove();
return adaptedMove instanceof NoChangeMove<Solution_>
|| adaptedMove instanceof ai.timefold.solver.core.impl.heuristic.selector.move.generic.ChangeMove<Solution_>;
} else {
return false;
}
}
protected void pickMove(ConstructionHeuristicStepScope<Solution_> stepScope) {
var pickedMoveScope = forager.pickMove(stepScope);
if (pickedMoveScope != null) {
var step = pickedMoveScope.getMove();
stepScope.setStep(step);
if (isLoggingEnabled() && logger.isDebugEnabled()) {
stepScope.setStepString(step.toString());
}
stepScope.setScore(pickedMoveScope.getScore());
}
}
protected void doMove(ConstructionHeuristicMoveScope<Solution_> moveScope) {
var scoreDirector = moveScope.getScoreDirector();
var score = scoreDirector.executeTemporaryMove(moveScope.getMove(), assertMoveScoreFromScratch);
moveScope.setScore(score);
forager.addMove(moveScope);
if (assertExpectedUndoMoveScore) {
scoreDirector.assertExpectedUndoMoveScore(moveScope.getMove(),
moveScope.getStepScope().getPhaseScope().getLastCompletedStepScope().getScore(),
SolverLifecyclePoint.of(moveScope));
}
if (isLoggingEnabled()) {
logger.trace("{} Move index ({}), score ({}), move ({}).",
logIndentation, moveScope.getMoveIndex(), moveScope.getScore().raw(), moveScope.getMove());
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider/forager/AbstractConstructionHeuristicForager.java | package ai.timefold.solver.core.impl.constructionheuristic.decider.forager;
import ai.timefold.solver.core.impl.constructionheuristic.event.ConstructionHeuristicPhaseLifecycleListenerAdapter;
public abstract class AbstractConstructionHeuristicForager<Solution_>
extends ConstructionHeuristicPhaseLifecycleListenerAdapter<Solution_>
implements ConstructionHeuristicForager<Solution_> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider/forager/ConstructionHeuristicForager.java | package ai.timefold.solver.core.impl.constructionheuristic.decider.forager;
import ai.timefold.solver.core.impl.constructionheuristic.event.ConstructionHeuristicPhaseLifecycleListener;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicMoveScope;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicStepScope;
/**
* @see AbstractConstructionHeuristicForager
*/
public interface ConstructionHeuristicForager<Solution_>
extends ConstructionHeuristicPhaseLifecycleListener<Solution_> {
void addMove(ConstructionHeuristicMoveScope<Solution_> moveScope);
boolean isQuitEarly();
ConstructionHeuristicMoveScope<Solution_> pickMove(ConstructionHeuristicStepScope<Solution_> stepScope);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider/forager/ConstructionHeuristicForagerFactory.java | package ai.timefold.solver.core.impl.constructionheuristic.decider.forager;
import ai.timefold.solver.core.config.constructionheuristic.decider.forager.ConstructionHeuristicForagerConfig;
import ai.timefold.solver.core.config.constructionheuristic.decider.forager.ConstructionHeuristicPickEarlyType;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
public class ConstructionHeuristicForagerFactory<Solution_> {
public static <Solution_> ConstructionHeuristicForagerFactory<Solution_> create(
ConstructionHeuristicForagerConfig foragerConfig) {
return new ConstructionHeuristicForagerFactory<>(foragerConfig);
}
private final ConstructionHeuristicForagerConfig foragerConfig;
public ConstructionHeuristicForagerFactory(ConstructionHeuristicForagerConfig foragerConfig) {
this.foragerConfig = foragerConfig;
}
public ConstructionHeuristicForager<Solution_> buildForager(HeuristicConfigPolicy<Solution_> configPolicy) {
ConstructionHeuristicPickEarlyType pickEarlyType_;
if (foragerConfig.getPickEarlyType() == null) {
pickEarlyType_ = configPolicy.getInitializingScoreTrend().isOnlyDown()
? ConstructionHeuristicPickEarlyType.FIRST_NON_DETERIORATING_SCORE
: ConstructionHeuristicPickEarlyType.NEVER;
} else {
pickEarlyType_ = foragerConfig.getPickEarlyType();
}
return new DefaultConstructionHeuristicForager<>(pickEarlyType_);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/decider/forager/DefaultConstructionHeuristicForager.java | package ai.timefold.solver.core.impl.constructionheuristic.decider.forager;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.config.constructionheuristic.decider.forager.ConstructionHeuristicPickEarlyType;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicMoveScope;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicStepScope;
public class DefaultConstructionHeuristicForager<Solution_> extends AbstractConstructionHeuristicForager<Solution_> {
protected final ConstructionHeuristicPickEarlyType pickEarlyType;
protected long selectedMoveCount;
protected ConstructionHeuristicMoveScope<Solution_> earlyPickedMoveScope;
protected ConstructionHeuristicMoveScope<Solution_> maxScoreMoveScope;
public DefaultConstructionHeuristicForager(ConstructionHeuristicPickEarlyType pickEarlyType) {
this.pickEarlyType = pickEarlyType;
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public void stepStarted(ConstructionHeuristicStepScope<Solution_> stepScope) {
super.stepStarted(stepScope);
selectedMoveCount = 0L;
earlyPickedMoveScope = null;
maxScoreMoveScope = null;
}
@Override
public void stepEnded(ConstructionHeuristicStepScope<Solution_> stepScope) {
super.stepEnded(stepScope);
earlyPickedMoveScope = null;
maxScoreMoveScope = null;
}
@Override
public void addMove(ConstructionHeuristicMoveScope<Solution_> moveScope) {
selectedMoveCount++;
moveScope.getStepScope().getPhaseScope()
.addMoveEvaluationCount(moveScope.getMove(), 1L);
checkPickEarly(moveScope);
if (maxScoreMoveScope == null || moveScope.getScore().compareTo(maxScoreMoveScope.getScore()) > 0) {
maxScoreMoveScope = moveScope;
}
}
protected <Score_ extends Score<Score_>> void checkPickEarly(ConstructionHeuristicMoveScope<Solution_> moveScope) {
switch (pickEarlyType) {
case NEVER -> {
}
case FIRST_NON_DETERIORATING_SCORE -> {
var lastStepScore = moveScope.getStepScope().getPhaseScope()
.getLastCompletedStepScope().<Score_> getScore().raw();
var moveScore = moveScope.<Score_> getScore().raw();
if (moveScore.compareTo(lastStepScore) >= 0) {
earlyPickedMoveScope = moveScope;
}
}
case FIRST_FEASIBLE_SCORE -> {
if (moveScope.getScore().raw().isFeasible()) {
earlyPickedMoveScope = moveScope;
}
}
case FIRST_FEASIBLE_SCORE_OR_NON_DETERIORATING_HARD -> {
var lastStepScore = moveScope.getStepScope().getPhaseScope()
.getLastCompletedStepScope().<Score_> getScore().raw();
var moveScore = moveScope.<Score_> getScore().raw();
var lastStepScoreDifference = moveScore.subtract(lastStepScore);
if (lastStepScoreDifference.isFeasible()) {
earlyPickedMoveScope = moveScope;
}
}
default ->
throw new IllegalStateException("The pickEarlyType (%s) is not implemented.".formatted(pickEarlyType));
}
}
@Override
public boolean isQuitEarly() {
return earlyPickedMoveScope != null;
}
@Override
public ConstructionHeuristicMoveScope<Solution_> pickMove(ConstructionHeuristicStepScope<Solution_> stepScope) {
stepScope.setSelectedMoveCount(selectedMoveCount);
if (earlyPickedMoveScope != null) {
return earlyPickedMoveScope;
} else {
return maxScoreMoveScope;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/event/ConstructionHeuristicPhaseLifecycleListener.java | package ai.timefold.solver.core.impl.constructionheuristic.event;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicPhaseScope;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicStepScope;
import ai.timefold.solver.core.impl.solver.event.SolverLifecycleListener;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see ConstructionHeuristicPhaseLifecycleListenerAdapter
*/
public interface ConstructionHeuristicPhaseLifecycleListener<Solution_> extends SolverLifecycleListener<Solution_> {
void phaseStarted(ConstructionHeuristicPhaseScope<Solution_> phaseScope);
void stepStarted(ConstructionHeuristicStepScope<Solution_> stepScope);
void stepEnded(ConstructionHeuristicStepScope<Solution_> stepScope);
void phaseEnded(ConstructionHeuristicPhaseScope<Solution_> phaseScope);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/event/ConstructionHeuristicPhaseLifecycleListenerAdapter.java | package ai.timefold.solver.core.impl.constructionheuristic.event;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicPhaseScope;
import ai.timefold.solver.core.impl.constructionheuristic.scope.ConstructionHeuristicStepScope;
import ai.timefold.solver.core.impl.solver.event.SolverLifecycleListenerAdapter;
/**
* An adapter for {@link ConstructionHeuristicPhaseLifecycleListener}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class ConstructionHeuristicPhaseLifecycleListenerAdapter<Solution_> extends SolverLifecycleListenerAdapter<Solution_>
implements ConstructionHeuristicPhaseLifecycleListener<Solution_> {
@Override
public void phaseStarted(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
// Hook method
}
@Override
public void stepStarted(ConstructionHeuristicStepScope<Solution_> stepScope) {
// Hook method
}
@Override
public void stepEnded(ConstructionHeuristicStepScope<Solution_> stepScope) {
// Hook method
}
@Override
public void phaseEnded(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
// Hook method
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/AbstractEntityPlacer.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.phase.event.PhaseLifecycleSupport;
import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Abstract superclass for {@link EntityPlacer}.
*
* @see EntityPlacer
*/
public abstract class AbstractEntityPlacer<Solution_> implements EntityPlacer<Solution_> {
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
protected final EntityPlacerFactory<Solution_> factory;
protected final HeuristicConfigPolicy<Solution_> configPolicy;
protected PhaseLifecycleSupport<Solution_> phaseLifecycleSupport = new PhaseLifecycleSupport<>();
AbstractEntityPlacer(EntityPlacerFactory<Solution_> factory, HeuristicConfigPolicy<Solution_> configPolicy) {
this.factory = factory;
this.configPolicy = configPolicy;
}
@Override
public EntityPlacer<Solution_> copy() {
if (factory == null || configPolicy == null) {
throw new IllegalStateException("The entity placer cannot be copied.");
}
return factory.buildEntityPlacer(configPolicy.copyConfigPolicy());
}
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
phaseLifecycleSupport.fireSolvingStarted(solverScope);
}
@Override
public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
phaseLifecycleSupport.firePhaseStarted(phaseScope);
}
@Override
public void stepStarted(AbstractStepScope<Solution_> stepScope) {
phaseLifecycleSupport.fireStepStarted(stepScope);
}
@Override
public void stepEnded(AbstractStepScope<Solution_> stepScope) {
phaseLifecycleSupport.fireStepEnded(stepScope);
}
@Override
public void phaseEnded(AbstractPhaseScope<Solution_> phaseScope) {
phaseLifecycleSupport.firePhaseEnded(phaseScope);
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
phaseLifecycleSupport.fireSolvingEnded(solverScope);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/AbstractEntityPlacerFactory.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import static ai.timefold.solver.core.config.heuristic.selector.common.SelectionCacheType.PHASE;
import static ai.timefold.solver.core.config.heuristic.selector.common.SelectionCacheType.STEP;
import ai.timefold.solver.core.config.constructionheuristic.placer.EntityPlacerConfig;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionOrder;
import ai.timefold.solver.core.config.heuristic.selector.entity.EntitySelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.ChangeMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.value.ValueSelectorConfig;
import ai.timefold.solver.core.impl.AbstractFromConfigFactory;
import ai.timefold.solver.core.impl.domain.variable.descriptor.GenuineVariableDescriptor;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
abstract class AbstractEntityPlacerFactory<Solution_, EntityPlacerConfig_ extends EntityPlacerConfig<EntityPlacerConfig_>>
extends AbstractFromConfigFactory<Solution_, EntityPlacerConfig_> implements EntityPlacerFactory<Solution_> {
protected AbstractEntityPlacerFactory(EntityPlacerConfig_ placerConfig) {
super(placerConfig);
}
protected ChangeMoveSelectorConfig buildChangeMoveSelectorConfig(HeuristicConfigPolicy<Solution_> configPolicy,
String entitySelectorConfigId, GenuineVariableDescriptor<Solution_> variableDescriptor) {
ChangeMoveSelectorConfig changeMoveSelectorConfig = new ChangeMoveSelectorConfig();
changeMoveSelectorConfig.setEntitySelectorConfig(
EntitySelectorConfig.newMimicSelectorConfig(entitySelectorConfigId));
ValueSelectorConfig changeValueSelectorConfig = new ValueSelectorConfig()
.withVariableName(variableDescriptor.getVariableName());
if (ValueSelectorConfig.hasSorter(configPolicy.getValueSorterManner(), variableDescriptor)) {
changeValueSelectorConfig = changeValueSelectorConfig
.withCacheType(variableDescriptor.canExtractValueRangeFromSolution() ? PHASE : STEP)
.withSelectionOrder(SelectionOrder.SORTED)
.withSorterManner(configPolicy.getValueSorterManner());
}
return changeMoveSelectorConfig.withValueSelectorConfig(changeValueSelectorConfig);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/EntityPlacer.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionFilter;
import ai.timefold.solver.core.impl.phase.event.PhaseLifecycleListener;
public interface EntityPlacer<Solution_> extends Iterable<Placement<Solution_>>, PhaseLifecycleListener<Solution_> {
EntityPlacer<Solution_> rebuildWithFilter(SelectionFilter<Solution_, Object> filter);
EntityPlacer<Solution_> copy();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/EntityPlacerFactory.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import ai.timefold.solver.core.config.constructionheuristic.placer.EntityPlacerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.PooledEntityPlacerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.QueuedEntityPlacerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.QueuedValuePlacerConfig;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
public interface EntityPlacerFactory<Solution_> {
@SuppressWarnings({ "rawtypes", "unchecked" })
static <Solution_> EntityPlacerFactory<Solution_> create(EntityPlacerConfig<?> entityPlacerConfig) {
if (entityPlacerConfig instanceof PooledEntityPlacerConfig pooledEntityPlacerConfig) {
return new PooledEntityPlacerFactory<>(pooledEntityPlacerConfig);
} else if (entityPlacerConfig instanceof QueuedEntityPlacerConfig queuedEntityPlacerConfig) {
return new QueuedEntityPlacerFactory<>(queuedEntityPlacerConfig);
} else if (entityPlacerConfig instanceof QueuedValuePlacerConfig queuedValuePlacerConfig) {
return new QueuedValuePlacerFactory<>(queuedValuePlacerConfig);
} else {
throw new IllegalArgumentException(String.format("Unknown %s type: (%s).",
EntityPlacerConfig.class.getSimpleName(), entityPlacerConfig.getClass().getName()));
}
}
EntityPlacer<Solution_> buildEntityPlacer(HeuristicConfigPolicy<Solution_> configPolicy);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/Placement.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import java.util.Iterator;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.preview.api.move.Move;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class Placement<Solution_> implements Iterable<Move<Solution_>> {
private final Iterator<Move<Solution_>> moveIterator;
public Placement(Iterator<Move<Solution_>> moveIterator) {
this.moveIterator = moveIterator;
}
@Override
public Iterator<Move<Solution_>> iterator() {
return moveIterator;
}
@Override
public String toString() {
return "Placement (" + moveIterator + ")";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/PooledEntityPlacer.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import java.util.Iterator;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.heuristic.move.Move;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionFilter;
import ai.timefold.solver.core.impl.heuristic.selector.common.iterator.UpcomingSelectionIterator;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.decorator.FilteringMoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.factory.MoveIteratorFactory;
public class PooledEntityPlacer<Solution_> extends AbstractEntityPlacer<Solution_> implements EntityPlacer<Solution_> {
protected final MoveSelector<Solution_> moveSelector;
public PooledEntityPlacer(EntityPlacerFactory<Solution_> factory, HeuristicConfigPolicy<Solution_> configPolicy,
MoveSelector<Solution_> moveSelector) {
super(factory, configPolicy);
this.moveSelector = moveSelector;
phaseLifecycleSupport.addEventListener(moveSelector);
}
@Override
public Iterator<Placement<Solution_>> iterator() {
return new PooledEntityPlacingIterator();
}
@Override
public EntityPlacer<Solution_> rebuildWithFilter(SelectionFilter<Solution_, Object> filter) {
return new PooledEntityPlacer<>(factory, configPolicy, FilteringMoveSelector.of(moveSelector, filter::accept));
}
private class PooledEntityPlacingIterator extends UpcomingSelectionIterator<Placement<Solution_>> {
private PooledEntityPlacingIterator() {
}
@Override
protected Placement<Solution_> createUpcomingSelection() {
Iterator<Move<Solution_>> moveIterator = moveSelector.iterator();
if (!moveIterator.hasNext()) {
return noUpcomingSelection();
}
return new Placement<>(MoveIteratorFactory.adaptIterator(moveIterator));
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/PooledEntityPlacerFactory.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.config.constructionheuristic.placer.PooledEntityPlacerConfig;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionCacheType;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionOrder;
import ai.timefold.solver.core.config.heuristic.selector.entity.EntitySelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.MoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.composite.CartesianProductMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.ChangeMoveSelectorConfig;
import ai.timefold.solver.core.impl.AbstractFromConfigFactory;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.GenuineVariableDescriptor;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelectorFactory;
public class PooledEntityPlacerFactory<Solution_>
extends AbstractEntityPlacerFactory<Solution_, PooledEntityPlacerConfig> {
public static <Solution_> PooledEntityPlacerConfig unfoldNew(HeuristicConfigPolicy<Solution_> configPolicy,
MoveSelectorConfig templateMoveSelectorConfig) {
PooledEntityPlacerConfig config = new PooledEntityPlacerConfig();
List<MoveSelectorConfig> leafMoveSelectorConfigList = new ArrayList<>();
MoveSelectorConfig moveSelectorConfig = (MoveSelectorConfig) templateMoveSelectorConfig.copyConfig();
moveSelectorConfig.extractLeafMoveSelectorConfigsIntoList(leafMoveSelectorConfigList);
config.setMoveSelectorConfig(moveSelectorConfig);
EntitySelectorConfig entitySelectorConfig = null;
for (MoveSelectorConfig leafMoveSelectorConfig : leafMoveSelectorConfigList) {
if (!(leafMoveSelectorConfig instanceof ChangeMoveSelectorConfig)) {
throw new IllegalStateException("The <constructionHeuristic> contains a moveSelector ("
+ leafMoveSelectorConfig + ") that isn't a <changeMoveSelector>, a <unionMoveSelector>"
+ " or a <cartesianProductMoveSelector>.\n"
+ "Maybe you're using a moveSelector in <constructionHeuristic>"
+ " that's only supported for <localSearch>.");
}
ChangeMoveSelectorConfig changeMoveSelectorConfig =
(ChangeMoveSelectorConfig) leafMoveSelectorConfig;
if (changeMoveSelectorConfig.getEntitySelectorConfig() != null) {
throw new IllegalStateException("The <constructionHeuristic> contains a changeMoveSelector ("
+ changeMoveSelectorConfig + ") that contains an entitySelector ("
+ changeMoveSelectorConfig.getEntitySelectorConfig()
+ ") without explicitly configuring the <pooledEntityPlacer>.");
}
if (entitySelectorConfig == null) {
EntityDescriptor<Solution_> entityDescriptor = new PooledEntityPlacerFactory<Solution_>(config)
.getTheOnlyEntityDescriptor(configPolicy.getSolutionDescriptor());
entitySelectorConfig =
AbstractFromConfigFactory.getDefaultEntitySelectorConfigForEntity(configPolicy, entityDescriptor);
changeMoveSelectorConfig.setEntitySelectorConfig(entitySelectorConfig);
}
changeMoveSelectorConfig.setEntitySelectorConfig(
EntitySelectorConfig.newMimicSelectorConfig(entitySelectorConfig.getId()));
}
return config;
}
public PooledEntityPlacerFactory(PooledEntityPlacerConfig placerConfig) {
super(placerConfig);
}
@Override
public PooledEntityPlacer<Solution_> buildEntityPlacer(HeuristicConfigPolicy<Solution_> configPolicy) {
MoveSelectorConfig moveSelectorConfig_ =
config.getMoveSelectorConfig() == null ? buildMoveSelectorConfig(configPolicy) : config.getMoveSelectorConfig();
MoveSelector<Solution_> moveSelector = MoveSelectorFactory.<Solution_> create(moveSelectorConfig_)
.buildMoveSelector(configPolicy, SelectionCacheType.JUST_IN_TIME, SelectionOrder.ORIGINAL, false);
return new PooledEntityPlacer<>(this, configPolicy, moveSelector);
}
private MoveSelectorConfig buildMoveSelectorConfig(HeuristicConfigPolicy<Solution_> configPolicy) {
EntityDescriptor<Solution_> entityDescriptor = getTheOnlyEntityDescriptor(configPolicy.getSolutionDescriptor());
EntitySelectorConfig entitySelectorConfig =
AbstractFromConfigFactory.getDefaultEntitySelectorConfigForEntity(configPolicy, entityDescriptor);
List<GenuineVariableDescriptor<Solution_>> variableDescriptors = entityDescriptor.getGenuineVariableDescriptorList();
List<MoveSelectorConfig> subMoveSelectorConfigList = new ArrayList<>(variableDescriptors.size());
for (GenuineVariableDescriptor<Solution_> variableDescriptor : variableDescriptors) {
subMoveSelectorConfigList
.add(buildChangeMoveSelectorConfig(configPolicy, entitySelectorConfig.getId(), variableDescriptor));
}
// The first entitySelectorConfig must be the mimic recorder, not the mimic replayer
((ChangeMoveSelectorConfig) subMoveSelectorConfigList.get(0)).setEntitySelectorConfig(entitySelectorConfig);
MoveSelectorConfig moveSelectorConfig_;
if (subMoveSelectorConfigList.size() > 1) {
// Default to cartesian product (not a union) of planning variables.
moveSelectorConfig_ = new CartesianProductMoveSelectorConfig(subMoveSelectorConfigList);
} else {
moveSelectorConfig_ = subMoveSelectorConfigList.get(0);
}
return moveSelectorConfig_;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/QueuedEntityPlacer.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.heuristic.move.Move;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionFilter;
import ai.timefold.solver.core.impl.heuristic.selector.common.iterator.UpcomingSelectionIterator;
import ai.timefold.solver.core.impl.heuristic.selector.entity.EntitySelector;
import ai.timefold.solver.core.impl.heuristic.selector.entity.decorator.FilteringEntitySelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.factory.MoveIteratorFactory;
public class QueuedEntityPlacer<Solution_> extends AbstractEntityPlacer<Solution_> implements EntityPlacer<Solution_> {
protected final EntitySelector<Solution_> entitySelector;
protected final List<MoveSelector<Solution_>> moveSelectorList;
public QueuedEntityPlacer(EntityPlacerFactory<Solution_> factory, HeuristicConfigPolicy<Solution_> configPolicy,
EntitySelector<Solution_> entitySelector, List<MoveSelector<Solution_>> moveSelectorList) {
super(factory, configPolicy);
this.entitySelector = entitySelector;
this.moveSelectorList = moveSelectorList;
phaseLifecycleSupport.addEventListener(entitySelector);
for (MoveSelector<Solution_> moveSelector : moveSelectorList) {
phaseLifecycleSupport.addEventListener(moveSelector);
}
}
@Override
public Iterator<Placement<Solution_>> iterator() {
return new QueuedEntityPlacingIterator(entitySelector.iterator());
}
@Override
public EntityPlacer<Solution_> rebuildWithFilter(SelectionFilter<Solution_, Object> filter) {
return new QueuedEntityPlacer<>(factory, configPolicy, FilteringEntitySelector.of(entitySelector, filter),
moveSelectorList);
}
private class QueuedEntityPlacingIterator extends UpcomingSelectionIterator<Placement<Solution_>> {
private final Iterator<Object> entityIterator;
private Iterator<MoveSelector<Solution_>> moveSelectorIterator;
private QueuedEntityPlacingIterator(Iterator<Object> entityIterator) {
this.entityIterator = entityIterator;
moveSelectorIterator = Collections.emptyIterator();
}
@Override
protected Placement<Solution_> createUpcomingSelection() {
Iterator<Move<Solution_>> moveIterator = null;
// Skip empty placements to avoid no-operation steps
while (moveIterator == null || !moveIterator.hasNext()) {
// If a moveSelector's iterator is empty, it might not be empty the next time
// (because the entity changes)
while (!moveSelectorIterator.hasNext()) {
if (!entityIterator.hasNext()) {
return noUpcomingSelection();
}
entityIterator.next();
moveSelectorIterator = moveSelectorList.iterator();
}
MoveSelector<Solution_> moveSelector = moveSelectorIterator.next();
moveIterator = moveSelector.iterator();
}
return new Placement<>(MoveIteratorFactory.adaptIterator(moveIterator));
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/QueuedEntityPlacerFactory.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import ai.timefold.solver.core.config.constructionheuristic.placer.QueuedEntityPlacerConfig;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionCacheType;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionOrder;
import ai.timefold.solver.core.config.heuristic.selector.entity.EntitySelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.MoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.composite.CartesianProductMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.ChangeMoveSelectorConfig;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.heuristic.selector.entity.EntitySelector;
import ai.timefold.solver.core.impl.heuristic.selector.entity.EntitySelectorFactory;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelectorFactory;
import org.jspecify.annotations.NonNull;
public class QueuedEntityPlacerFactory<Solution_>
extends AbstractEntityPlacerFactory<Solution_, QueuedEntityPlacerConfig> {
@SuppressWarnings({ "rawtypes", "unchecked" })
public static <Solution_> QueuedEntityPlacerConfig unfoldNew(HeuristicConfigPolicy<Solution_> configPolicy,
List<MoveSelectorConfig> templateMoveSelectorConfigList) {
var config = new QueuedEntityPlacerConfig();
var entitySelectorConfig = new QueuedEntityPlacerFactory<Solution_>(config)
.buildEntitySelectorConfig(configPolicy);
config.setEntitySelectorConfig(entitySelectorConfig);
var moveSelectorConfigList = new ArrayList<MoveSelectorConfig>(templateMoveSelectorConfigList.size());
config.setMoveSelectorConfigList(moveSelectorConfigList);
var leafMoveSelectorConfigList = new ArrayList<MoveSelectorConfig>(templateMoveSelectorConfigList.size());
for (var templateMoveSelectorConfig : templateMoveSelectorConfigList) {
var moveSelectorConfig = (MoveSelectorConfig) templateMoveSelectorConfig.copyConfig();
moveSelectorConfig.extractLeafMoveSelectorConfigsIntoList(leafMoveSelectorConfigList);
moveSelectorConfigList.add(moveSelectorConfig);
}
for (var leafMoveSelectorConfig : leafMoveSelectorConfigList) {
if (!(leafMoveSelectorConfig instanceof ChangeMoveSelectorConfig changeMoveSelectorConfig)) {
throw new IllegalStateException(
"""
The <constructionHeuristic> contains a moveSelector (%s) that isn't a <changeMoveSelector>, \
a <unionMoveSelector> or a <cartesianProductMoveSelector>.
Maybe you're using a moveSelector in <constructionHeuristic> that's only supported for <localSearch>."""
.formatted(leafMoveSelectorConfig));
}
var changeMoveEntitySelectorConfig = changeMoveSelectorConfig.getEntitySelectorConfig();
if (changeMoveEntitySelectorConfig != null) {
throw new IllegalStateException(
"The <constructionHeuristic> contains a changeMoveSelector (%s) that contains an entitySelector (%s) without explicitly configuring the <queuedEntityPlacer>."
.formatted(changeMoveSelectorConfig, changeMoveEntitySelectorConfig));
}
changeMoveSelectorConfig.setEntitySelectorConfig(
EntitySelectorConfig.newMimicSelectorConfig(entitySelectorConfig.getId()));
}
return config;
}
public QueuedEntityPlacerFactory(QueuedEntityPlacerConfig placerConfig) {
super(placerConfig);
}
@Override
public QueuedEntityPlacer<Solution_> buildEntityPlacer(HeuristicConfigPolicy<Solution_> configPolicy) {
var entitySelectorConfig_ = buildEntitySelectorConfig(configPolicy);
var entitySelector = EntitySelectorFactory.<Solution_> create(entitySelectorConfig_).buildEntitySelector(configPolicy,
SelectionCacheType.PHASE, SelectionOrder.ORIGINAL);
var moveSelectorConfigList_ = getMoveSelectorConfigs(configPolicy, entitySelector, entitySelectorConfig_);
var moveSelectorList = new ArrayList<MoveSelector<Solution_>>(moveSelectorConfigList_.size());
for (var moveSelectorConfig : moveSelectorConfigList_) {
var moveSelector = MoveSelectorFactory.<Solution_> create(moveSelectorConfig)
.buildMoveSelector(configPolicy, SelectionCacheType.JUST_IN_TIME, SelectionOrder.ORIGINAL, false);
moveSelectorList.add(moveSelector);
}
return new QueuedEntityPlacer<>(this, configPolicy, entitySelector, moveSelectorList);
}
@SuppressWarnings("rawtypes")
private @NonNull List<MoveSelectorConfig> getMoveSelectorConfigs(HeuristicConfigPolicy<Solution_> configPolicy,
EntitySelector<Solution_> entitySelector, EntitySelectorConfig entitySelectorConfig_) {
var moveSelectorConfigList = config.getMoveSelectorConfigList();
if (!ConfigUtils.isEmptyCollection(moveSelectorConfigList)) {
return moveSelectorConfigList;
}
var entityDescriptor = entitySelector.getEntityDescriptor();
var variableDescriptorList = entityDescriptor.getGenuineVariableDescriptorList().stream()
.filter(variableDescriptor -> !variableDescriptor.isListVariable())
.toList();
var subMoveSelectorConfigList = new ArrayList<MoveSelectorConfig>(variableDescriptorList.size());
for (var variableDescriptor : variableDescriptorList) {
subMoveSelectorConfigList
.add(buildChangeMoveSelectorConfig(configPolicy, entitySelectorConfig_.getId(), variableDescriptor));
}
if (subMoveSelectorConfigList.size() > 1) {
// Default to cartesian product (not a queue) of planning variables.
return Collections.singletonList(new CartesianProductMoveSelectorConfig(subMoveSelectorConfigList));
} else {
return Collections.singletonList(subMoveSelectorConfigList.get(0));
}
}
public EntitySelectorConfig buildEntitySelectorConfig(HeuristicConfigPolicy<Solution_> configPolicy) {
var entitySelectorConfig = config.getEntitySelectorConfig();
if (entitySelectorConfig == null) {
var entityDescriptor = getTheOnlyEntityDescriptorWithBasicVariables(configPolicy.getSolutionDescriptor());
entitySelectorConfig = getDefaultEntitySelectorConfigForEntity(configPolicy, entityDescriptor);
} else {
// The default phase configuration generates the entity selector config without an updated version of the configuration policy.
// We need to ensure that there are no missing sorting settings.
var entityDescriptor = deduceEntityDescriptor(configPolicy, entitySelectorConfig.getEntityClass());
entitySelectorConfig = deduceEntitySortManner(configPolicy, entityDescriptor, entitySelectorConfig);
}
var cacheType = entitySelectorConfig.getCacheType();
if (cacheType != null && cacheType.compareTo(SelectionCacheType.PHASE) < 0) {
throw new IllegalArgumentException(
"The queuedEntityPlacer (%s) cannot have an entitySelectorConfig (%s) with a cacheType (%s) lower than %s."
.formatted(config, entitySelectorConfig, cacheType, SelectionCacheType.PHASE));
}
return entitySelectorConfig;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/QueuedValuePlacer.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import java.util.Collections;
import java.util.Iterator;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionFilter;
import ai.timefold.solver.core.impl.heuristic.selector.common.iterator.UpcomingSelectionIterator;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.factory.MoveIteratorFactory;
import ai.timefold.solver.core.impl.heuristic.selector.move.generic.list.ListChangeMoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.value.IterableValueSelector;
import ai.timefold.solver.core.impl.heuristic.selector.value.decorator.FilteringValueSelector;
import ai.timefold.solver.core.impl.heuristic.selector.value.decorator.IterableFilteringValueSelector;
public class QueuedValuePlacer<Solution_> extends AbstractEntityPlacer<Solution_> implements EntityPlacer<Solution_> {
protected final IterableValueSelector<Solution_> valueSelector;
protected final MoveSelector<Solution_> moveSelector;
public QueuedValuePlacer(EntityPlacerFactory<Solution_> factory, HeuristicConfigPolicy<Solution_> configPolicy,
IterableValueSelector<Solution_> valueSelector, MoveSelector<Solution_> moveSelector) {
super(factory, configPolicy);
this.valueSelector = valueSelector;
this.moveSelector = moveSelector;
phaseLifecycleSupport.addEventListener(valueSelector);
phaseLifecycleSupport.addEventListener(moveSelector);
}
@Override
public Iterator<Placement<Solution_>> iterator() {
return new QueuedValuePlacingIterator();
}
public boolean hasListChangeMoveSelector() {
return moveSelector instanceof ListChangeMoveSelector<Solution_>;
}
private class QueuedValuePlacingIterator extends UpcomingSelectionIterator<Placement<Solution_>> {
private Iterator<Object> valueIterator;
private QueuedValuePlacingIterator() {
valueIterator = Collections.emptyIterator();
}
@Override
protected Placement<Solution_> createUpcomingSelection() {
// If all values are used, there can still be entities uninitialized
if (!valueIterator.hasNext()) {
valueIterator = valueSelector.iterator();
if (!valueIterator.hasNext()) {
return noUpcomingSelection();
}
}
valueIterator.next();
var moveIterator = moveSelector.iterator();
// Because the valueSelector is entity independent, there is always a move if there's still an entity
if (!moveIterator.hasNext()) {
return noUpcomingSelection();
}
return new Placement<>(MoveIteratorFactory.adaptIterator(moveIterator));
}
}
@Override
public EntityPlacer<Solution_> rebuildWithFilter(SelectionFilter<Solution_, Object> filter) {
return new QueuedValuePlacer<>(factory, configPolicy,
(IterableFilteringValueSelector<Solution_>) FilteringValueSelector.of(valueSelector, filter),
moveSelector);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/placer/QueuedValuePlacerFactory.java | package ai.timefold.solver.core.impl.constructionheuristic.placer;
import java.util.Objects;
import ai.timefold.solver.core.api.domain.valuerange.ValueRangeProvider;
import ai.timefold.solver.core.config.constructionheuristic.placer.QueuedValuePlacerConfig;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionCacheType;
import ai.timefold.solver.core.config.heuristic.selector.common.SelectionOrder;
import ai.timefold.solver.core.config.heuristic.selector.entity.EntitySelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.MoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.move.generic.ChangeMoveSelectorConfig;
import ai.timefold.solver.core.config.heuristic.selector.value.ValueSelectorConfig;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.GenuineVariableDescriptor;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelector;
import ai.timefold.solver.core.impl.heuristic.selector.move.MoveSelectorFactory;
import ai.timefold.solver.core.impl.heuristic.selector.value.IterableValueSelector;
import ai.timefold.solver.core.impl.heuristic.selector.value.ValueSelector;
import ai.timefold.solver.core.impl.heuristic.selector.value.ValueSelectorFactory;
public class QueuedValuePlacerFactory<Solution_>
extends AbstractEntityPlacerFactory<Solution_, QueuedValuePlacerConfig> {
public static QueuedValuePlacerConfig unfoldNew(MoveSelectorConfig templateMoveSelectorConfig) {
throw new UnsupportedOperationException(
"The <constructionHeuristic> contains a moveSelector (%s) and the <queuedValuePlacer> does not support unfolding those yet."
.formatted(templateMoveSelectorConfig));
}
public QueuedValuePlacerFactory(QueuedValuePlacerConfig placerConfig) {
super(placerConfig);
}
@Override
public QueuedValuePlacer<Solution_> buildEntityPlacer(HeuristicConfigPolicy<Solution_> configPolicy) {
EntityDescriptor<Solution_> entityDescriptor = deduceEntityDescriptor(configPolicy, config.getEntityClass());
ValueSelectorConfig valueSelectorConfig_ = buildValueSelectorConfig(configPolicy, entityDescriptor);
// TODO improve the ValueSelectorFactory API (avoid the boolean flags).
ValueSelector<Solution_> valueSelector = ValueSelectorFactory.<Solution_> create(valueSelectorConfig_)
.buildValueSelector(configPolicy, entityDescriptor, SelectionCacheType.PHASE, SelectionOrder.ORIGINAL,
false, // override applyReinitializeVariableFiltering
ValueSelectorFactory.ListValueFilteringType.ACCEPT_UNASSIGNED);
MoveSelectorConfig<?> moveSelectorConfig_ = config.getMoveSelectorConfig() == null
? buildChangeMoveSelectorConfig(configPolicy, valueSelectorConfig_.getId(),
valueSelector.getVariableDescriptor())
: config.getMoveSelectorConfig();
MoveSelector<Solution_> moveSelector = MoveSelectorFactory.<Solution_> create(moveSelectorConfig_)
.buildMoveSelector(configPolicy, SelectionCacheType.JUST_IN_TIME, SelectionOrder.ORIGINAL, false);
if (!(valueSelector instanceof IterableValueSelector<Solution_> iterableValueSelector)) {
throw new IllegalArgumentException(
"The queuedValuePlacer (%s) needs to be based on an %s (%s). Check your @%s annotations.".formatted(this,
IterableValueSelector.class.getSimpleName(), valueSelector,
ValueRangeProvider.class.getSimpleName()));
}
return new QueuedValuePlacer<>(this, configPolicy, iterableValueSelector, moveSelector);
}
private ValueSelectorConfig buildValueSelectorConfig(HeuristicConfigPolicy<Solution_> configPolicy,
EntityDescriptor<Solution_> entityDescriptor) {
var result = Objects.requireNonNullElseGet(config.getValueSelectorConfig(),
() -> {
var entityClass = entityDescriptor.getEntityClass();
var variableDescriptor = getTheOnlyVariableDescriptor(entityDescriptor);
var valueSelectorConfig = new ValueSelectorConfig()
.withId(entityClass.getName() + "." + variableDescriptor.getVariableName())
.withVariableName(variableDescriptor.getVariableName());
if (ValueSelectorConfig.hasSorter(configPolicy.getValueSorterManner(), variableDescriptor)) {
valueSelectorConfig = valueSelectorConfig.withCacheType(SelectionCacheType.PHASE)
.withSelectionOrder(SelectionOrder.SORTED)
.withSorterManner(configPolicy.getValueSorterManner());
}
return valueSelectorConfig;
});
var cacheType = result.getCacheType();
if (cacheType != null && cacheType.compareTo(SelectionCacheType.PHASE) < 0) {
throw new IllegalArgumentException(
"The queuedValuePlacer (%s) cannot have a valueSelectorConfig (%s) with a cacheType (%s) lower than %s."
.formatted(this, result, cacheType, SelectionCacheType.PHASE));
}
return result;
}
@Override
protected ChangeMoveSelectorConfig buildChangeMoveSelectorConfig(
HeuristicConfigPolicy<Solution_> configPolicy, String valueSelectorConfigId,
GenuineVariableDescriptor<Solution_> variableDescriptor) {
ChangeMoveSelectorConfig changeMoveSelectorConfig = new ChangeMoveSelectorConfig();
EntityDescriptor<Solution_> entityDescriptor = variableDescriptor.getEntityDescriptor();
EntitySelectorConfig changeEntitySelectorConfig = new EntitySelectorConfig()
.withEntityClass(entityDescriptor.getEntityClass());
if (configPolicy.getEntitySorterManner() != null
&& EntitySelectorConfig.hasSorter(configPolicy.getEntitySorterManner(), entityDescriptor)) {
changeEntitySelectorConfig = changeEntitySelectorConfig.withCacheType(SelectionCacheType.PHASE)
.withSelectionOrder(SelectionOrder.SORTED)
.withSorterManner(configPolicy.getEntitySorterManner());
}
ValueSelectorConfig changeValueSelectorConfig = new ValueSelectorConfig()
.withVariableName(variableDescriptor.getVariableName())
.withMimicSelectorRef(valueSelectorConfigId);
return changeMoveSelectorConfig.withEntitySelectorConfig(changeEntitySelectorConfig)
.withValueSelectorConfig(changeValueSelectorConfig);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/scope/ConstructionHeuristicMoveScope.java | package ai.timefold.solver.core.impl.constructionheuristic.scope;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.phase.scope.AbstractMoveScope;
import ai.timefold.solver.core.preview.api.move.Move;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public final class ConstructionHeuristicMoveScope<Solution_> extends AbstractMoveScope<Solution_> {
public ConstructionHeuristicMoveScope(ConstructionHeuristicStepScope<Solution_> stepScope, int moveIndex,
Move<Solution_> move) {
super(stepScope, moveIndex, move);
}
@Override
public ConstructionHeuristicStepScope<Solution_> getStepScope() {
return (ConstructionHeuristicStepScope<Solution_>) super.getStepScope();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/scope/ConstructionHeuristicPhaseScope.java | package ai.timefold.solver.core.impl.constructionheuristic.scope;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class ConstructionHeuristicPhaseScope<Solution_> extends AbstractPhaseScope<Solution_> {
private ConstructionHeuristicStepScope<Solution_> lastCompletedStepScope;
public ConstructionHeuristicPhaseScope(SolverScope<Solution_> solverScope, int phaseIndex) {
super(solverScope, phaseIndex, false);
lastCompletedStepScope = new ConstructionHeuristicStepScope<>(this, -1);
}
@Override
public ConstructionHeuristicStepScope<Solution_> getLastCompletedStepScope() {
return lastCompletedStepScope;
}
public void setLastCompletedStepScope(ConstructionHeuristicStepScope<Solution_> lastCompletedStepScope) {
this.lastCompletedStepScope = lastCompletedStepScope;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/constructionheuristic/scope/ConstructionHeuristicStepScope.java | package ai.timefold.solver.core.impl.constructionheuristic.scope;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
import ai.timefold.solver.core.preview.api.move.Move;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public final class ConstructionHeuristicStepScope<Solution_> extends AbstractStepScope<Solution_> {
private final ConstructionHeuristicPhaseScope<Solution_> phaseScope;
private Object entity = null;
private Move<Solution_> step = null;
private String stepString = null;
private Long selectedMoveCount = null;
public ConstructionHeuristicStepScope(ConstructionHeuristicPhaseScope<Solution_> phaseScope) {
this(phaseScope, phaseScope.getNextStepIndex());
}
public ConstructionHeuristicStepScope(ConstructionHeuristicPhaseScope<Solution_> phaseScope, int stepIndex) {
super(stepIndex);
this.phaseScope = phaseScope;
}
@Override
public ConstructionHeuristicPhaseScope<Solution_> getPhaseScope() {
return phaseScope;
}
public Object getEntity() {
return entity;
}
public void setEntity(Object entity) {
this.entity = entity;
}
public Move<Solution_> getStep() {
return step;
}
public void setStep(Move<Solution_> step) {
this.step = step;
}
/**
* @return null if logging level is too high
*/
public String getStepString() {
return stepString;
}
public void setStepString(String stepString) {
this.stepString = stepString;
}
public Long getSelectedMoveCount() {
return selectedMoveCount;
}
public void setSelectedMoveCount(Long selectedMoveCount) {
this.selectedMoveCount = selectedMoveCount;
}
// ************************************************************************
// Calculated methods
// ************************************************************************
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/AlphabeticMemberComparator.java | package ai.timefold.solver.core.impl.domain.common;
import java.lang.reflect.Constructor;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.Comparator;
public class AlphabeticMemberComparator implements Comparator<Member> {
@Override
public int compare(Member a, Member b) {
int compareTo = a.getName().compareTo(b.getName());
if (compareTo != 0) {
return compareTo;
}
if (a instanceof Method method) {
if (!(b instanceof Method)) {
return 1;
}
int parameterNameCompareTo = compareParameterTypes(
method.getParameterTypes(),
((Method) b).getParameterTypes());
if (parameterNameCompareTo != 0) {
return parameterNameCompareTo;
}
} else if (b instanceof Method) {
return -1;
}
if (a instanceof Constructor constructor) {
if (!(b instanceof Constructor)) {
return 1;
}
int parameterNameCompareTo = compareParameterTypes(
constructor.getParameterTypes(),
((Constructor) b).getParameterTypes());
if (parameterNameCompareTo != 0) {
return parameterNameCompareTo;
}
} else if (b instanceof Constructor) {
return -1;
}
return 0;
}
protected int compareParameterTypes(Class<?>[] aParameterTypes, Class<?>[] bParameterTypes) {
if (aParameterTypes.length != bParameterTypes.length) {
return aParameterTypes.length > bParameterTypes.length ? 1 : -1;
}
for (int i = 0; i < aParameterTypes.length; i++) {
int parameterNameCompareTo = aParameterTypes[i].getName().compareTo(bParameterTypes[i].getName());
if (parameterNameCompareTo != 0) {
return parameterNameCompareTo;
}
}
return 0;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/ReflectionHelper.java | /*
* Copied from the Hibernate Validator project
* Original authors: Hardy Ferentschik, Gunnar Morling and Kevin Pollet.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package ai.timefold.solver.core.impl.domain.common;
import java.lang.annotation.Annotation;
import java.lang.reflect.Array;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
public final class ReflectionHelper {
private static final String PROPERTY_ACCESSOR_PREFIX_GET = "get";
private static final String PROPERTY_ACCESSOR_PREFIX_IS = "is";
private static final String[] PROPERTY_ACCESSOR_PREFIXES = {
PROPERTY_ACCESSOR_PREFIX_GET,
PROPERTY_ACCESSOR_PREFIX_IS
};
private static final String PROPERTY_MUTATOR_PREFIX = "set";
/**
* Returns the JavaBeans property name of the given member.
*
* @param member never null
* @return null if the member is neither a field nor a getter method according to the JavaBeans standard
*/
public static String getGetterPropertyName(Member member) {
if (member instanceof Field) {
return member.getName();
} else if (member instanceof Method) {
String methodName = member.getName();
for (String prefix : PROPERTY_ACCESSOR_PREFIXES) {
if (methodName.startsWith(prefix)) {
return decapitalizePropertyName(methodName.substring(prefix.length()));
}
}
}
return null;
}
private static String decapitalizePropertyName(String propertyName) {
if (propertyName.isEmpty() || startsWithSeveralUpperCaseLetters(propertyName)) {
return propertyName;
} else {
return propertyName.substring(0, 1).toLowerCase() + propertyName.substring(1);
}
}
private static boolean startsWithSeveralUpperCaseLetters(String propertyName) {
return propertyName.length() > 1 &&
Character.isUpperCase(propertyName.charAt(0)) &&
Character.isUpperCase(propertyName.charAt(1));
}
/**
* Checks whether the given method is a valid getter method according to the JavaBeans standard.
*
* @param method never null
* @return true if the given method is a getter method
*/
public static boolean isGetterMethod(Method method) {
if (method.getParameterTypes().length != 0) {
return false;
}
String methodName = method.getName();
if (methodName.startsWith(PROPERTY_ACCESSOR_PREFIX_GET) && method.getReturnType() != void.class) {
return true;
} else if (methodName.startsWith(PROPERTY_ACCESSOR_PREFIX_IS) && method.getReturnType() == boolean.class) {
return true;
}
return false;
}
/**
* @param containingClass never null
* @param propertyName never null
* @return true if that getter exists
*/
public static boolean hasGetterMethod(Class<?> containingClass, String propertyName) {
return getGetterMethod(containingClass, propertyName) != null;
}
/**
* @param containingClass never null
* @param propertyName never null
* @return sometimes null
*/
public static Method getGetterMethod(Class<?> containingClass, String propertyName) {
String capitalizedPropertyName = capitalizePropertyName(propertyName);
String getterName = PROPERTY_ACCESSOR_PREFIX_GET + capitalizedPropertyName;
try {
return containingClass.getMethod(getterName);
} catch (NoSuchMethodException e) {
// intentionally empty
}
String isserName = PROPERTY_ACCESSOR_PREFIX_IS + capitalizedPropertyName;
try {
Method method = containingClass.getMethod(isserName);
if (method.getReturnType() == boolean.class) {
return method;
}
} catch (NoSuchMethodException e) {
// intentionally empty
}
return null;
}
/**
* @param containingClass never null
* @param propertyName never null
* @return sometimes null
*/
public static Method getDeclaredGetterMethod(Class<?> containingClass, String propertyName) {
var capitalizedPropertyName = capitalizePropertyName(propertyName);
var getterName = PROPERTY_ACCESSOR_PREFIX_GET + capitalizedPropertyName;
var baseClass = containingClass;
while (baseClass != null) {
try {
return baseClass.getDeclaredMethod(getterName);
} catch (NoSuchMethodException e) {
baseClass = baseClass.getSuperclass();
}
}
var isserName = PROPERTY_ACCESSOR_PREFIX_IS + capitalizedPropertyName;
baseClass = containingClass;
while (baseClass != null) {
try {
return baseClass.getDeclaredMethod(isserName);
} catch (NoSuchMethodException e) {
baseClass = baseClass.getSuperclass();
}
}
return null;
}
/**
* @param containingClass never null
* @param methodName never null
* @return sometimes null
*/
public static Method getDeclaredMethod(Class<?> containingClass, String methodName, Class<?>... parameterTypes) {
var baseClass = containingClass;
while (baseClass != null) {
try {
return baseClass.getDeclaredMethod(methodName, parameterTypes);
} catch (NoSuchMethodException e) {
baseClass = baseClass.getSuperclass();
}
}
return null;
}
private static String capitalizePropertyName(String propertyName) {
if (propertyName.isEmpty() || Character.isUpperCase(propertyName.charAt(0))) {
return propertyName;
} else {
return propertyName.substring(0, 1).toUpperCase() + propertyName.substring(1);
}
}
/**
* @param containingClass never null
* @param fieldName never null
* @return true if that field exists
*/
public static boolean hasField(Class<?> containingClass, String fieldName) {
return getField(containingClass, fieldName) != null;
}
/**
* @param containingClass never null
* @param fieldName never null
* @return sometimes null
*/
public static Field getField(Class<?> containingClass, String fieldName) {
try {
return containingClass.getField(fieldName);
} catch (NoSuchFieldException e) {
return null;
}
}
/**
* @param containingClass never null
* @param fieldName never null
* @return sometimes null
*/
public static Field getDeclaredField(Class<?> containingClass, String fieldName) {
var baseClass = containingClass;
while (baseClass != null) {
try {
return baseClass.getDeclaredField(fieldName);
} catch (NoSuchFieldException e) {
baseClass = baseClass.getSuperclass();
}
}
return null;
}
/**
* @param containingClass never null
* @param propertyType never null
* @param propertyName never null
* @return null if it doesn't exist
*/
public static Method getSetterMethod(Class<?> containingClass, Class<?> propertyType, String propertyName) {
String setterName = PROPERTY_MUTATOR_PREFIX + capitalizePropertyName(propertyName);
try {
return containingClass.getMethod(setterName, propertyType);
} catch (NoSuchMethodException e) {
return null;
}
}
/**
* @param containingClass never null
* @param propertyType never null
* @param propertyName never null
* @return null if it doesn't exist
*/
public static Method getDeclaredSetterMethod(Class<?> containingClass, Class<?> propertyType, String propertyName) {
String setterName = PROPERTY_MUTATOR_PREFIX + capitalizePropertyName(propertyName);
return getDeclaredMethod(containingClass, setterName, propertyType);
}
/**
* @param containingClass never null
* @param propertyName never null
* @return null if it doesn't exist
*/
public static Method getSetterMethod(Class<?> containingClass, String propertyName) {
String setterName = PROPERTY_MUTATOR_PREFIX + capitalizePropertyName(propertyName);
Method[] methods = Arrays.stream(containingClass.getMethods())
.filter(method -> method.getName().equals(setterName))
.toArray(Method[]::new);
if (methods.length == 0) {
return null;
}
if (methods.length > 1) {
throw new IllegalStateException("The containingClass (" + containingClass
+ ") has multiple setter methods (" + Arrays.toString(methods)
+ ") with the propertyName (" + propertyName + ").");
}
return methods[0];
}
public static boolean isMethodOverwritten(Method parentMethod, Class<?> childClass) {
Method leafMethod;
try {
leafMethod = childClass.getDeclaredMethod(parentMethod.getName(), parentMethod.getParameterTypes());
} catch (NoSuchMethodException e) {
return false;
}
return !leafMethod.getDeclaringClass().equals(parentMethod.getClass());
}
public static void assertGetterMethod(Method getterMethod) {
if (getterMethod.getParameterTypes().length != 0) {
throw new IllegalStateException("The getterMethod (%s) must not have any parameters (%s)."
.formatted(getterMethod, Arrays.toString(getterMethod.getParameterTypes())));
}
var methodName = getterMethod.getName();
if (methodName.startsWith(PROPERTY_ACCESSOR_PREFIX_GET)) {
if (getterMethod.getReturnType() == void.class) {
throw new IllegalStateException(
"The getterMethod (%s) must have a non-void return type (%s)."
.formatted(getterMethod, getterMethod.getReturnType()));
}
} else if (methodName.startsWith(PROPERTY_ACCESSOR_PREFIX_IS)) {
if (getterMethod.getReturnType() != boolean.class) {
throw new IllegalStateException("""
The getterMethod (%s) must have a primitive boolean return type (%s) \
or use another prefix in its methodName (%s).
Maybe use '%s' instead of '%s'?"""
.formatted(getterMethod, getterMethod.getReturnType(), methodName, PROPERTY_ACCESSOR_PREFIX_GET,
PROPERTY_ACCESSOR_PREFIX_IS));
}
} else {
throw new IllegalStateException(
"The getterMethod (%s) has a methodName (%s) that does not start with a valid prefix (%s)."
.formatted(getterMethod, methodName, Arrays.toString(PROPERTY_ACCESSOR_PREFIXES)));
}
}
public static void assertGetterMethod(Method getterMethod, Class<? extends Annotation> annotationClass) {
if (getterMethod.getParameterTypes().length != 0) {
throw new IllegalStateException("The getterMethod (%s) with a %s annotation must not have any parameters (%s)."
.formatted(getterMethod, annotationClass.getSimpleName(),
Arrays.toString(getterMethod.getParameterTypes())));
}
var methodName = getterMethod.getName();
if (methodName.startsWith(PROPERTY_ACCESSOR_PREFIX_GET)) {
if (getterMethod.getReturnType() == void.class) {
throw new IllegalStateException(
"The getterMethod (%s) with a %s annotation must have a non-void return type (%s)."
.formatted(getterMethod, annotationClass.getSimpleName(), getterMethod.getReturnType()));
}
} else if (methodName.startsWith(PROPERTY_ACCESSOR_PREFIX_IS)) {
if (getterMethod.getReturnType() != boolean.class) {
throw new IllegalStateException("""
The getterMethod (%s) with a %s annotation must have a primitive boolean return type (%s) \
or use another prefix in its methodName (%s).
Maybe use '%s' instead of '%s'?"""
.formatted(getterMethod, annotationClass.getSimpleName(), getterMethod.getReturnType(), methodName,
PROPERTY_ACCESSOR_PREFIX_GET, PROPERTY_ACCESSOR_PREFIX_IS));
}
} else {
throw new IllegalStateException(
"The getterMethod (%s) with a %s annotation has a methodName (%s) that does not start with a valid prefix (%s)."
.formatted(getterMethod, annotationClass.getSimpleName(), methodName,
Arrays.toString(PROPERTY_ACCESSOR_PREFIXES)));
}
}
public static void assertReadMethod(Method readMethod) {
if (readMethod.getParameterTypes().length != 0) {
throw new IllegalStateException("The readMethod (%s) must not have any parameters (%s)."
.formatted(readMethod, Arrays.toString(readMethod.getParameterTypes())));
}
if (readMethod.getReturnType() == void.class) {
throw new IllegalStateException("The readMethod (%s) must have a non-void return type (%s)."
.formatted(readMethod, readMethod.getReturnType()));
}
}
public static void assertReadMethod(Method readMethod, Class<? extends Annotation> annotationClass) {
if (readMethod.getParameterTypes().length != 0) {
throw new IllegalStateException("The readMethod (%s) with a %s annotation must not have any parameters (%s)."
.formatted(readMethod, annotationClass.getSimpleName(), Arrays.toString(readMethod.getParameterTypes())));
}
if (readMethod.getReturnType() == void.class) {
throw new IllegalStateException("The readMethod (%s) with a %s annotation must have a non-void return type (%s)."
.formatted(readMethod, annotationClass.getSimpleName(), readMethod.getReturnType()));
}
}
@SuppressWarnings("unchecked")
public static <Value_> List<Value_> transformArrayToList(Object arrayObject) {
if (arrayObject == null) {
return null;
}
var arrayLength = Array.getLength(arrayObject);
var list = new ArrayList<Value_>(arrayLength);
for (var i = 0; i < arrayLength; i++) {
list.add((Value_) Array.get(arrayObject, i));
}
return list;
}
private ReflectionHelper() {
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/AbstractMemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor;
import java.util.function.Function;
public abstract class AbstractMemberAccessor implements MemberAccessor {
// We cache this so that the same reference is always returned; useful for CS node sharing.
private final Function getterFunction = this::executeGetter;
@Override
public final <Fact_, Result_> Function<Fact_, Result_> getGetterFunction() {
return getterFunction;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/FieldHandle.java | package ai.timefold.solver.core.impl.domain.common.accessor;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Field;
public record FieldHandle(Field field, MethodHandle getter, MethodHandle setter) {
public static FieldHandle of(Field field) {
try {
field.setAccessible(true);
var getter = MethodHandles.lookup().unreflectGetter(field);
var setter = MethodHandles.lookup().unreflectSetter(field);
return new FieldHandle(field, getter, setter);
} catch (IllegalAccessException e) {
throw new IllegalStateException(
"The field (%s) cannot be accessed to create a planning clone."
.formatted(field),
e);
}
}
public Object get(Object bean) {
try { // Don't null-check the bean; if null, it fails anyway.
return getter.invoke(bean);
} catch (Throwable e) {
var beanClass = bean == null ? "null" : bean.getClass();
throw new IllegalStateException(
"Cannot get the field (%s) on bean of class (%s)."
.formatted(field.getName(), beanClass),
e);
}
}
public void set(Object bean, Object value) {
try { // Don't null-check the bean; if null, it fails anyway.
setter.invoke(bean, value);
} catch (Throwable e) {
var beanClass = bean == null ? "null" : bean.getClass();
throw new IllegalStateException(
"Cannot set the field (%s) on bean of class (%s)."
.formatted(field.getName(), beanClass),
e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/MemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.function.Function;
/**
* Fast and easy access to a {@link Member} of a bean,
* which is a property (with a getter and optional setter {@link Method}) or a {@link Field}.
*
* @see ReflectionBeanPropertyMemberAccessor
* @see ReflectionFieldMemberAccessor
* @see ReflectionMethodMemberAccessor
*/
public interface MemberAccessor {
Class<?> getDeclaringClass();
String getName();
Class<?> getType();
/**
* As defined by {@link Method#getGenericReturnType()} and {@link Field#getGenericType()}.
*
* @return never null
*/
Type getGenericType();
Object executeGetter(Object bean);
/**
* In order to support node sharing in constraint streams, we need to reference {@link #executeGetter(Object)}
* in a way so that the method reference stays the same instance.
* This method returns just such a method reference.
*
* @param <Result_>
* @return never null, a constant reference to {@link #executeGetter(Object)}
*/
<Fact_, Result_> Function<Fact_, Result_> getGetterFunction();
boolean supportSetter();
void executeSetter(Object bean, Object value);
String getSpeedNote();
/**
* As defined in {@link AnnotatedElement#getAnnotation(Class)}.
*/
<T extends Annotation> T getAnnotation(Class<T> annotationClass);
<T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/MemberAccessorFactory.java | package ai.timefold.solver.core.impl.domain.common.accessor;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.ConcurrentHashMap;
import ai.timefold.solver.core.api.domain.common.DomainAccessType;
import ai.timefold.solver.core.api.solver.SolverFactory;
import ai.timefold.solver.core.impl.domain.common.ReflectionHelper;
import ai.timefold.solver.core.impl.domain.common.accessor.gizmo.GizmoClassLoader;
import ai.timefold.solver.core.impl.domain.common.accessor.gizmo.GizmoMemberAccessorFactory;
public final class MemberAccessorFactory {
// exists only so that the various member accessors can share the same text in their exception messages
static final String CLASSLOADER_NUDGE_MESSAGE =
"Maybe add getClass().getClassLoader() as a parameter to the %s.create...() method call."
.formatted(SolverFactory.class.getSimpleName());
/**
* Creates a new member accessor based on the given parameters.
*
* @param member never null, method or field to access
* @param memberAccessorType never null
* @param domainAccessType never null
* @param classLoader null or {@link GizmoClassLoader} if domainAccessType is {@link DomainAccessType#GIZMO}.
* @return never null, new instance of the member accessor
*/
public static MemberAccessor buildMemberAccessor(Member member, MemberAccessorType memberAccessorType,
DomainAccessType domainAccessType, ClassLoader classLoader) {
return buildMemberAccessor(member, memberAccessorType, null, domainAccessType, classLoader);
}
/**
* Creates a new member accessor based on the given parameters.
*
* @param member never null, method or field to access
* @param memberAccessorType never null
* @param annotationClass the annotation the member was annotated with (used for error reporting)
* @param domainAccessType never null
* @param classLoader null or {@link GizmoClassLoader} if domainAccessType is {@link DomainAccessType#GIZMO}.
* @return never null, new instance of the member accessor
*/
public static MemberAccessor buildMemberAccessor(Member member, MemberAccessorType memberAccessorType,
Class<? extends Annotation> annotationClass, DomainAccessType domainAccessType, ClassLoader classLoader) {
return switch (domainAccessType) {
case GIZMO -> GizmoMemberAccessorFactory.buildGizmoMemberAccessor(member, annotationClass,
memberAccessorType != MemberAccessorType.VOID_METHOD,
(GizmoClassLoader) Objects.requireNonNull(classLoader));
case REFLECTION -> buildReflectiveMemberAccessor(member, memberAccessorType, annotationClass);
};
}
private static MemberAccessor buildReflectiveMemberAccessor(Member member, MemberAccessorType memberAccessorType,
Class<? extends Annotation> annotationClass) {
if (member instanceof Field field) {
return new ReflectionFieldMemberAccessor(field);
} else if (member instanceof Method method) {
MemberAccessor memberAccessor;
switch (memberAccessorType) {
case FIELD_OR_READ_METHOD:
if (!ReflectionHelper.isGetterMethod(method)) {
if (annotationClass == null) {
ReflectionHelper.assertReadMethod(method);
} else {
ReflectionHelper.assertReadMethod(method, annotationClass);
}
memberAccessor = new ReflectionMethodMemberAccessor(method);
break;
}
// Intentionally fall through (no break)
case FIELD_OR_GETTER_METHOD:
case FIELD_OR_GETTER_METHOD_WITH_SETTER:
boolean getterOnly = memberAccessorType != MemberAccessorType.FIELD_OR_GETTER_METHOD_WITH_SETTER;
if (annotationClass == null) {
ReflectionHelper.assertGetterMethod(method);
} else {
ReflectionHelper.assertGetterMethod(method, annotationClass);
}
memberAccessor = new ReflectionBeanPropertyMemberAccessor(method, getterOnly);
break;
case VOID_METHOD:
memberAccessor = new ReflectionMethodMemberAccessor(method, false);
break;
default:
throw new IllegalStateException("The memberAccessorType (%s) is not implemented."
.formatted(memberAccessorType));
}
if (memberAccessorType == MemberAccessorType.FIELD_OR_GETTER_METHOD_WITH_SETTER
&& !memberAccessor.supportSetter()) {
if (annotationClass == null) {
throw new IllegalStateException(
"The class (%s) has a getter method (%s), but lacks a setter for that property (%s)."
.formatted(method.getDeclaringClass(), method, memberAccessor.getName()));
} else {
throw new IllegalStateException(
"The class (%s) has a @%s-annotated getter method (%s), but lacks a setter for that property (%s)."
.formatted(method.getDeclaringClass(), annotationClass.getSimpleName(), method,
memberAccessor.getName()));
}
}
return memberAccessor;
} else {
throw new IllegalStateException("Impossible state: the member (%s)'s type is not a %s or a %s."
.formatted(member, Field.class.getSimpleName(), Method.class.getSimpleName()));
}
}
private final Map<String, MemberAccessor> memberAccessorCache;
private final GizmoClassLoader gizmoClassLoader = new GizmoClassLoader();
public MemberAccessorFactory() {
this(null);
}
/**
* Prefills the member accessor cache.
*
* @param memberAccessorMap key is the fully qualified member name
*/
public MemberAccessorFactory(Map<String, MemberAccessor> memberAccessorMap) {
// The MemberAccessorFactory may be accessed, and this cache both read and updated, by multiple threads.
this.memberAccessorCache =
memberAccessorMap == null ? new ConcurrentHashMap<>() : new ConcurrentHashMap<>(memberAccessorMap);
}
/**
* Creates a new member accessor based on the given parameters. Caches the result.
*
* @param member never null, method or field to access
* @param memberAccessorType never null
* @param annotationClass the annotation the member was annotated with (used for error reporting)
* @param domainAccessType never null
* @return never null, new {@link MemberAccessor} instance unless already found in memberAccessorMap
*/
public MemberAccessor buildAndCacheMemberAccessor(Member member, MemberAccessorType memberAccessorType,
Class<? extends Annotation> annotationClass, DomainAccessType domainAccessType) {
String generatedClassName = GizmoMemberAccessorFactory.getGeneratedClassName(member);
return memberAccessorCache.computeIfAbsent(generatedClassName,
k -> MemberAccessorFactory.buildMemberAccessor(member, memberAccessorType, annotationClass, domainAccessType,
gizmoClassLoader));
}
/**
* Creates a new member accessor based on the given parameters. Caches the result.
*
* @param member never null, method or field to access
* @param memberAccessorType never null
* @param domainAccessType never null
* @return never null, new {@link MemberAccessor} instance unless already found in memberAccessorMap
*/
public MemberAccessor buildAndCacheMemberAccessor(Member member, MemberAccessorType memberAccessorType,
DomainAccessType domainAccessType) {
String generatedClassName = GizmoMemberAccessorFactory.getGeneratedClassName(member);
return memberAccessorCache.computeIfAbsent(generatedClassName,
k -> MemberAccessorFactory.buildMemberAccessor(member, memberAccessorType, domainAccessType, gizmoClassLoader));
}
public GizmoClassLoader getGizmoClassLoader() {
return gizmoClassLoader;
}
public enum MemberAccessorType {
FIELD_OR_READ_METHOD,
FIELD_OR_GETTER_METHOD,
FIELD_OR_GETTER_METHOD_WITH_SETTER,
VOID_METHOD
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/ReflectionBeanPropertyMemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor;
import java.lang.annotation.Annotation;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.function.IntPredicate;
import ai.timefold.solver.core.impl.domain.common.ReflectionHelper;
/**
* A {@link MemberAccessor} based on a getter and optionally a setter.
*/
public final class ReflectionBeanPropertyMemberAccessor extends AbstractMemberAccessor {
private final Class<?> propertyType;
private final String propertyName;
private final Method getterMethod;
private final MethodHandle getherMethodHandle;
private final Method setterMethod;
private final MethodHandle setterMethodHandle;
public ReflectionBeanPropertyMemberAccessor(Method getterMethod) {
this(getterMethod, false);
}
public ReflectionBeanPropertyMemberAccessor(Method getterMethod, boolean getterOnly) {
this.getterMethod = getterMethod;
MethodHandles.Lookup lookup = MethodHandles.lookup();
try {
getterMethod.setAccessible(true); // Performance hack by avoiding security checks
this.getherMethodHandle = lookup.unreflect(getterMethod)
.asFixedArity();
} catch (IllegalAccessException e) {
throw new IllegalStateException("""
Impossible state: method (%s) not accessible.
%s"""
.formatted(getterMethod, MemberAccessorFactory.CLASSLOADER_NUDGE_MESSAGE), e);
}
Class<?> declaringClass = getterMethod.getDeclaringClass();
if (!ReflectionHelper.isGetterMethod(getterMethod)) {
throw new IllegalArgumentException("The getterMethod (%s) is not a valid getter."
.formatted(getterMethod));
}
propertyType = getterMethod.getReturnType();
propertyName = ReflectionHelper.getGetterPropertyName(getterMethod);
if (getterOnly) {
setterMethod = null;
setterMethodHandle = null;
} else {
setterMethod = ReflectionHelper.getDeclaredSetterMethod(declaringClass, getterMethod.getReturnType(), propertyName);
if (setterMethod == null) {
throw new IllegalArgumentException("The getterMethod (%s) does not have a matching setterMethod on class (%s)."
.formatted(getterMethod.getName(), declaringClass.getCanonicalName()));
}
var getterAccess = AccessModifier.forMethod(getterMethod);
var setterAccess = AccessModifier.forMethod(setterMethod);
if (getterAccess != setterAccess) {
throw new IllegalArgumentException(
"The getterMethod (%s) has access modifier (%s) which does not match the setterMethod (%s) access modifier (%s) on class (%s)."
.formatted(getterMethod.getName(), getterAccess, setterMethod.getName(), setterAccess,
declaringClass.getCanonicalName()));
}
try {
setterMethod.setAccessible(true); // Performance hack by avoiding security checks
this.setterMethodHandle = lookup.unreflect(setterMethod)
.asFixedArity();
} catch (IllegalAccessException e) {
throw new IllegalStateException("""
Impossible state: method (%s) not accessible.
%s"""
.formatted(setterMethod, MemberAccessorFactory.CLASSLOADER_NUDGE_MESSAGE), e);
}
}
}
private enum AccessModifier {
PUBLIC("public", Modifier::isPublic),
PROTECTED("protected", Modifier::isProtected),
PACKAGE_PRIVATE("package-private", modifier -> false),
PRIVATE("private", Modifier::isPrivate);
final String name;
final IntPredicate predicate;
AccessModifier(String name, IntPredicate predicate) {
this.name = name;
this.predicate = predicate;
}
public static AccessModifier forMethod(Method method) {
var modifiers = method.getModifiers();
for (var accessModifier : AccessModifier.values()) {
if (accessModifier.predicate.test(modifiers)) {
return accessModifier;
}
}
return PACKAGE_PRIVATE;
}
@Override
public String toString() {
return name;
}
}
@Override
public Class<?> getDeclaringClass() {
return getterMethod.getDeclaringClass();
}
@Override
public String getName() {
return propertyName;
}
@Override
public Class<?> getType() {
return propertyType;
}
@Override
public Type getGenericType() {
return getterMethod.getGenericReturnType();
}
@Override
public Object executeGetter(Object bean) {
if (bean == null) {
throw new IllegalArgumentException("Requested property (%s) getterMethod (%s) on a null bean."
.formatted(propertyName, getterMethod));
}
try {
return getherMethodHandle.invoke(bean);
} catch (Throwable e) {
throw new IllegalStateException("The property (%s) getterMethod (%s) on bean of class (%s) throws an exception."
.formatted(propertyName, getterMethod, bean.getClass()), e);
}
}
@Override
public boolean supportSetter() {
return setterMethod != null;
}
@Override
public void executeSetter(Object bean, Object value) {
if (bean == null) {
throw new IllegalArgumentException("Requested property (%s) setterMethod (%s) on a null bean."
.formatted(propertyName, setterMethod));
}
try {
setterMethodHandle.invoke(bean, value);
} catch (Throwable e) {
throw new IllegalStateException("The property (%s) setterMethod (%s) on bean of class (%s) throws an exception."
.formatted(propertyName, setterMethod, bean.getClass()), e);
}
}
@Override
public String getSpeedNote() {
return "MethodHandle";
}
@Override
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
return getterMethod.getAnnotation(annotationClass);
}
@Override
public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
return getterMethod.getDeclaredAnnotationsByType(annotationClass);
}
@Override
public String toString() {
return "bean property " + propertyName + " on " + getterMethod.getDeclaringClass();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/ReflectionFieldMemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Type;
/**
* A {@link MemberAccessor} based on a field.
*/
public final class ReflectionFieldMemberAccessor extends AbstractMemberAccessor {
private final FieldHandle fieldHandle;
public ReflectionFieldMemberAccessor(Field field) {
this.fieldHandle = FieldHandle.of(field); // Use MethodHandles to access the field.
}
@Override
public Class<?> getDeclaringClass() {
return fieldHandle.field().getDeclaringClass();
}
@Override
public String getName() {
return fieldHandle.field().getName();
}
@Override
public Class<?> getType() {
return fieldHandle.field().getType();
}
@Override
public Type getGenericType() {
return fieldHandle.field().getGenericType();
}
@Override
public Object executeGetter(Object bean) {
var field = fieldHandle.field();
if (bean == null) {
throw new IllegalArgumentException("Requested field (%s) on a null bean."
.formatted(field));
}
return fieldHandle.get(bean);
}
@Override
public boolean supportSetter() {
return true;
}
@Override
public void executeSetter(Object bean, Object value) {
var field = fieldHandle.field();
if (bean == null) {
throw new IllegalArgumentException("Requested field (%s) on a null bean."
.formatted(field));
}
fieldHandle.set(bean, value);
}
@Override
public String getSpeedNote() {
return "reflection";
}
@Override
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
return fieldHandle.field().getAnnotation(annotationClass);
}
@Override
public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
return fieldHandle.field().getDeclaredAnnotationsByType(annotationClass);
}
@Override
public String toString() {
return "field " + fieldHandle.field();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/ReflectionMethodMemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor;
import java.lang.annotation.Annotation;
import java.lang.invoke.MethodHandle;
import java.lang.invoke.MethodHandles;
import java.lang.reflect.Method;
import java.lang.reflect.Type;
import java.util.Arrays;
/**
* A {@link MemberAccessor} based on a single read {@link Method}.
* Do not confuse with {@link ReflectionBeanPropertyMemberAccessor} which is richer.
*/
public final class ReflectionMethodMemberAccessor extends AbstractMemberAccessor {
private final Class<?> returnType;
private final String methodName;
private final Method readMethod;
private final MethodHandle methodHandle;
public ReflectionMethodMemberAccessor(Method readMethod) {
this(readMethod, true);
}
public ReflectionMethodMemberAccessor(Method readMethod, boolean returnTypeRequired) {
this.readMethod = readMethod;
this.returnType = readMethod.getReturnType();
this.methodName = readMethod.getName();
try {
readMethod.setAccessible(true);
this.methodHandle = MethodHandles.lookup()
.unreflect(readMethod)
.asFixedArity();
} catch (IllegalAccessException e) {
throw new IllegalStateException("""
Impossible state: Method (%s) not accessible.
%s
""".formatted(readMethod, MemberAccessorFactory.CLASSLOADER_NUDGE_MESSAGE), e);
}
if (readMethod.getParameterTypes().length != 0) {
throw new IllegalArgumentException("The readMethod (" + readMethod + ") must not have any parameters ("
+ Arrays.toString(readMethod.getParameterTypes()) + ").");
}
if (returnTypeRequired && readMethod.getReturnType() == void.class) {
throw new IllegalArgumentException("The readMethod (" + readMethod + ") must have a return type ("
+ readMethod.getReturnType() + ").");
}
}
@Override
public Class<?> getDeclaringClass() {
return readMethod.getDeclaringClass();
}
@Override
public String getName() {
return methodName;
}
@Override
public Class<?> getType() {
return returnType;
}
@Override
public Type getGenericType() {
return readMethod.getGenericReturnType();
}
@Override
public Object executeGetter(Object bean) {
try {
return methodHandle.invoke(bean);
} catch (Throwable e) {
throw new IllegalStateException("The property (%s) getterMethod (%s) on bean of class (%s) throws an exception."
.formatted(methodName, readMethod, bean.getClass()), e);
}
}
@Override
public String getSpeedNote() {
return "MethodHandle";
}
@Override
public boolean supportSetter() {
return false;
}
@Override
public void executeSetter(Object bean, Object value) {
throw new UnsupportedOperationException();
}
@Override
public <T extends Annotation> T getAnnotation(Class<T> annotationClass) {
return readMethod.getAnnotation(annotationClass);
}
@Override
public <T extends Annotation> T[] getDeclaredAnnotationsByType(Class<T> annotationClass) {
return readMethod.getDeclaredAnnotationsByType(annotationClass);
}
@Override
public String toString() {
return "method " + methodName + " on " + readMethod.getDeclaringClass();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/AbstractGizmoMemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import ai.timefold.solver.core.impl.domain.common.accessor.AbstractMemberAccessor;
/**
* This and its subclasses exist so that Gizmo only needs to generate code where it is necessary for it to be generated.
* This helps to keep Gizmo code-generation to a minimum,
* maintaining as much as possible the benefits of static typing and IDE-assisted refactoring.
*/
public abstract class AbstractGizmoMemberAccessor extends AbstractMemberAccessor {
@Override
public final String getSpeedNote() {
return "Fast access with generated bytecode";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/AbstractReadOnlyGizmoMemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
public abstract class AbstractReadOnlyGizmoMemberAccessor extends AbstractGizmoMemberAccessor {
@Override
public final boolean supportSetter() {
return false;
}
@Override
public final void executeSetter(Object bean, Object value) {
throw new UnsupportedOperationException("Setter not supported");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/AbstractReadWriteGizmoMemberAccessor.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
public abstract class AbstractReadWriteGizmoMemberAccessor extends AbstractGizmoMemberAccessor {
@Override
public final boolean supportSetter() {
return true;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoClassLoader.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.util.HashMap;
import java.util.Map;
/**
* Loads a class if we have the Gizmo-generated bytecode for it,
* otherwise uses the current {@link Thread}'s context {@link ClassLoader}.
* This implementation is thread-safe.
*/
public final class GizmoClassLoader extends ClassLoader {
private final Map<String, byte[]> classNameToBytecodeMap = new HashMap<>();
public GizmoClassLoader() {
/*
* As parent, Gizmo needs to use the same ClassLoader that loaded its own class.
* Otherwise, issues will arise in Quarkus with MemberAccessors which were first loaded by Quarkus
* and then loaded again by Gizmo, which uses the default parent ClassLoader.
*/
super(GizmoClassLoader.class.getClassLoader());
}
@Override
public String getName() {
return "Timefold Solver Gizmo ClassLoader";
}
@Override
public Class<?> findClass(String name) throws ClassNotFoundException {
byte[] byteCode = getBytecodeFor(name);
if (byteCode == null) { // Not a Gizmo generated class; load from context class loader.
return Thread.currentThread().getContextClassLoader().loadClass(name);
} else { // Gizmo generated class.
return defineClass(name, byteCode, 0, byteCode.length);
}
}
public synchronized byte[] getBytecodeFor(String className) {
return classNameToBytecodeMap.get(className);
}
public boolean hasBytecodeFor(String className) {
return getBytecodeFor(className) != null;
}
public synchronized void storeBytecode(String className, byte[] bytecode) {
classNameToBytecodeMap.put(className, bytecode);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoFieldHandler.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.lang.reflect.Type;
import java.util.function.Consumer;
import io.quarkus.gizmo.BytecodeCreator;
import io.quarkus.gizmo.FieldDescriptor;
import io.quarkus.gizmo.MethodDescriptor;
import io.quarkus.gizmo.ResultHandle;
final class GizmoFieldHandler implements GizmoMemberHandler {
private final Class<?> declaringClass;
private final FieldDescriptor fieldDescriptor;
private final boolean canBeWritten;
GizmoFieldHandler(Class<?> declaringClass, FieldDescriptor fieldDescriptor, boolean canBeWritten) {
this.declaringClass = declaringClass;
this.fieldDescriptor = fieldDescriptor;
this.canBeWritten = canBeWritten;
}
@Override
public void whenIsField(Consumer<FieldDescriptor> fieldDescriptorConsumer) {
fieldDescriptorConsumer.accept(fieldDescriptor);
}
@Override
public void whenIsMethod(Consumer<MethodDescriptor> methodDescriptorConsumer) {
// Do nothing.
}
@Override
public ResultHandle readMemberValue(BytecodeCreator bytecodeCreator, ResultHandle thisObj) {
return bytecodeCreator.readInstanceField(fieldDescriptor, thisObj);
}
@Override
public boolean writeMemberValue(MethodDescriptor setter, BytecodeCreator bytecodeCreator, ResultHandle thisObj,
ResultHandle newValue) {
if (canBeWritten) {
bytecodeCreator.writeInstanceField(fieldDescriptor, thisObj, newValue);
return true;
} else {
return false;
}
}
@Override
public String getDeclaringClassName() {
return fieldDescriptor.getDeclaringClass();
}
@Override
public String getTypeName() {
return fieldDescriptor.getType();
}
@Override
public Type getType() {
try {
return declaringClass.getDeclaredField(fieldDescriptor.getName()).getGenericType();
} catch (NoSuchFieldException e) {
throw new IllegalStateException(
"Cannot find field (" + fieldDescriptor.getName() + ") on class (" + declaringClass + ").",
e);
}
}
@Override
public String toString() {
return fieldDescriptor.toString();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoMemberAccessorFactory.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.lang.annotation.Annotation;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.util.Objects;
import ai.timefold.solver.core.api.domain.common.DomainAccessType;
import ai.timefold.solver.core.impl.domain.common.ReflectionHelper;
import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
public class GizmoMemberAccessorFactory {
/**
* Returns the generated class name for a given member.
* (Here as accessing any method of GizmoMemberAccessorImplementor
* will try to load Gizmo code)
*
* @param member The member to get the generated class name for
* @return The generated class name for member
*/
public static String getGeneratedClassName(Member member) {
String memberName = Objects.requireNonNullElse(ReflectionHelper.getGetterPropertyName(member), member.getName());
String memberType = (member instanceof Field) ? "Field" : "Method";
return member.getDeclaringClass().getName() + "$Timefold$MemberAccessor$" + memberType + "$" + memberName;
}
/**
*
* @param member never null
* @param annotationClass may be null if the member is not annotated
* @param gizmoClassLoader never null
* @return never null
*/
public static MemberAccessor buildGizmoMemberAccessor(Member member, Class<? extends Annotation> annotationClass,
boolean returnTypeRequired, GizmoClassLoader gizmoClassLoader) {
try {
// Check if Gizmo on the classpath by verifying we can access one of its classes
Class.forName("io.quarkus.gizmo.ClassCreator", false,
Thread.currentThread().getContextClassLoader());
} catch (ClassNotFoundException e) {
throw new IllegalStateException("When using the domainAccessType (" +
DomainAccessType.GIZMO +
") the classpath or modulepath must contain io.quarkus.gizmo:gizmo.\n" +
"Maybe add a dependency to io.quarkus.gizmo:gizmo.");
}
return GizmoMemberAccessorImplementor.createAccessorFor(member, annotationClass, returnTypeRequired, gizmoClassLoader);
}
private GizmoMemberAccessorFactory() {
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoMemberAccessorImplementor.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.Arrays;
import java.util.concurrent.atomic.AtomicBoolean;
import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
import ai.timefold.solver.core.impl.util.MutableReference;
import io.quarkus.gizmo.ClassCreator;
import io.quarkus.gizmo.ClassOutput;
import io.quarkus.gizmo.FieldDescriptor;
import io.quarkus.gizmo.MethodCreator;
import io.quarkus.gizmo.MethodDescriptor;
import io.quarkus.gizmo.ResultHandle;
/**
* Generates the bytecode for the MemberAccessor of a particular Member
*/
public final class GizmoMemberAccessorImplementor {
final static String GENERIC_TYPE_FIELD = "genericType";
final static String ANNOTATED_ELEMENT_FIELD = "annotatedElement";
/**
* Generates the constructor and implementations of {@link AbstractGizmoMemberAccessor} methods for the given
* {@link Member}.
*
* @param className never null
* @param classOutput never null, defines how to write the bytecode
* @param memberInfo never null, member to generate MemberAccessor methods implementation for
*/
public static void defineAccessorFor(String className, ClassOutput classOutput, GizmoMemberInfo memberInfo) {
Class<? extends AbstractGizmoMemberAccessor> superClass = getCorrectSuperclass(memberInfo);
try (ClassCreator classCreator = ClassCreator.builder()
.className(className)
.superClass(superClass)
.classOutput(classOutput)
.setFinal(true)
.build()) {
classCreator.getFieldCreator("genericType", Type.class)
.setModifiers(Modifier.FINAL);
classCreator.getFieldCreator("annotatedElement", AnnotatedElement.class)
.setModifiers(Modifier.FINAL);
// ************************************************************************
// MemberAccessor methods
// ************************************************************************
createConstructor(classCreator, memberInfo);
createGetDeclaringClass(classCreator, memberInfo);
createGetType(classCreator, memberInfo);
createGetGenericType(classCreator);
createGetName(classCreator, memberInfo);
createExecuteGetter(classCreator, memberInfo);
if (superClass == AbstractReadWriteGizmoMemberAccessor.class) {
createExecuteSetter(classCreator, memberInfo);
}
createGetAnnotation(classCreator);
createDeclaredAnnotationsByType(classCreator);
}
}
private static Class<? extends AbstractGizmoMemberAccessor> getCorrectSuperclass(GizmoMemberInfo memberInfo) {
AtomicBoolean supportsSetter = new AtomicBoolean();
memberInfo.descriptor().whenIsMethod(method -> {
supportsSetter.set(memberInfo.descriptor().getSetter().isPresent());
});
memberInfo.descriptor().whenIsField(field -> {
supportsSetter.set(true);
});
if (supportsSetter.get()) {
return AbstractReadWriteGizmoMemberAccessor.class;
} else {
return AbstractReadOnlyGizmoMemberAccessor.class;
}
}
/**
* Creates a MemberAccessor for a given member, generating
* the MemberAccessor bytecode if required
*
* @param member The member to generate a MemberAccessor for
* @param annotationClass The annotation it was annotated with (used for
* error reporting)
* @param returnTypeRequired A flag that indicates if the return type is required or optional
* @param gizmoClassLoader never null
* @return A new MemberAccessor that uses Gizmo generated bytecode.
* Will generate the bytecode the first type it is called
* for a member, unless a classloader has been set,
* in which case no Gizmo code will be generated.
*/
static MemberAccessor createAccessorFor(Member member, Class<? extends Annotation> annotationClass,
boolean returnTypeRequired, GizmoClassLoader gizmoClassLoader) {
String className = GizmoMemberAccessorFactory.getGeneratedClassName(member);
if (gizmoClassLoader.hasBytecodeFor(className)) {
return createInstance(className, gizmoClassLoader);
}
final MutableReference<byte[]> classBytecodeHolder = new MutableReference<>(null);
ClassOutput classOutput = (path, byteCode) -> classBytecodeHolder.setValue(byteCode);
GizmoMemberInfo memberInfo =
new GizmoMemberInfo(new GizmoMemberDescriptor(member), returnTypeRequired, annotationClass);
defineAccessorFor(className, classOutput, memberInfo);
byte[] classBytecode = classBytecodeHolder.getValue();
gizmoClassLoader.storeBytecode(className, classBytecode);
return createInstance(className, gizmoClassLoader);
}
private static MemberAccessor createInstance(String className, GizmoClassLoader gizmoClassLoader) {
try {
return (MemberAccessor) gizmoClassLoader.loadClass(className)
.getConstructor().newInstance();
} catch (InvocationTargetException | InstantiationException | IllegalAccessException | ClassNotFoundException
| NoSuchMethodException e) {
throw new IllegalStateException(e);
}
}
// ************************************************************************
// MemberAccessor methods
// ************************************************************************
private static MethodCreator getMethodCreator(ClassCreator classCreator, Class<?> returnType, String methodName,
Class<?>... parameters) {
return classCreator.getMethodCreator(methodName, returnType, parameters);
}
private static void createConstructor(ClassCreator classCreator, GizmoMemberInfo memberInfo) {
MethodCreator methodCreator =
classCreator.getMethodCreator(MethodDescriptor.ofConstructor(classCreator.getClassName()));
ResultHandle thisObj = methodCreator.getThis();
// Invoke Object's constructor
methodCreator.invokeSpecialMethod(MethodDescriptor.ofConstructor(classCreator.getSuperClass()), thisObj);
ResultHandle declaringClass = methodCreator.loadClass(memberInfo.descriptor().getDeclaringClassName());
memberInfo.descriptor().whenMetadataIsOnField(fd -> {
ResultHandle name = methodCreator.load(fd.getName());
ResultHandle field = methodCreator.invokeVirtualMethod(MethodDescriptor.ofMethod(Class.class, "getDeclaredField",
Field.class, String.class),
declaringClass, name);
ResultHandle type =
methodCreator.invokeVirtualMethod(MethodDescriptor.ofMethod(Field.class, "getGenericType", Type.class),
field);
methodCreator.writeInstanceField(FieldDescriptor.of(classCreator.getClassName(), GENERIC_TYPE_FIELD, Type.class),
thisObj, type);
methodCreator.writeInstanceField(
FieldDescriptor.of(classCreator.getClassName(), ANNOTATED_ELEMENT_FIELD, AnnotatedElement.class),
thisObj, field);
});
memberInfo.descriptor().whenMetadataIsOnMethod(md -> {
ResultHandle name = methodCreator.load(md.getName());
ResultHandle method = methodCreator.invokeVirtualMethod(MethodDescriptor.ofMethod(Class.class, "getDeclaredMethod",
Method.class, String.class, Class[].class),
declaringClass, name,
methodCreator.newArray(Class.class, 0));
if (memberInfo.returnTypeRequired()) {
// We create a field to store the result, only if the called method has a return type.
// Otherwise, we will only execute it
ResultHandle type =
methodCreator.invokeVirtualMethod(
MethodDescriptor.ofMethod(Method.class, "getGenericReturnType", Type.class),
method);
methodCreator.writeInstanceField(
FieldDescriptor.of(classCreator.getClassName(), GENERIC_TYPE_FIELD, Type.class),
thisObj, type);
}
methodCreator.writeInstanceField(
FieldDescriptor.of(classCreator.getClassName(), ANNOTATED_ELEMENT_FIELD, AnnotatedElement.class),
thisObj, method);
});
// Return this (it a constructor)
methodCreator.returnValue(thisObj);
}
/**
* Generates the following code:
*
* <pre>
* Class getDeclaringClass() {
* return ClassThatDeclaredMember.class;
* }
* </pre>
*/
private static void createGetDeclaringClass(ClassCreator classCreator, GizmoMemberInfo memberInfo) {
MethodCreator methodCreator = getMethodCreator(classCreator, Class.class, "getDeclaringClass");
ResultHandle out = methodCreator.loadClass(memberInfo.descriptor().getDeclaringClassName());
methodCreator.returnValue(out);
}
/**
* Asserts method is a getter or read method
*
* @param method Method to assert is getter or read
* @param returnTypeRequired Flag used to check method return type
*/
private static void assertIsGoodMethod(MethodDescriptor method, boolean returnTypeRequired) {
// V = void return type
// Z = primitive boolean return type
String methodName = method.getName();
if (method.getParameterTypes().length != 0) {
// not read or getter method
throw new IllegalStateException("The getterMethod (%s) must not have any parameters, but has parameters (%s)."
.formatted(methodName, Arrays.toString(method.getParameterTypes())));
}
if (methodName.startsWith("get")) {
if (method.getReturnType().equals("V")) {
throw new IllegalStateException("The getterMethod (%s) must have a non-void return type."
.formatted(methodName));
}
} else if (methodName.startsWith("is")) {
if (!method.getReturnType().equals("Z")) {
throw new IllegalStateException("""
The getterMethod (%s) must have a primitive boolean return type but returns (%s).
Maybe rename the method (get%s)?"""
.formatted(methodName, method.getReturnType(), methodName.substring(2)));
}
} else {
// must be a read method
if (returnTypeRequired && method.getReturnType().equals("V")) {
throw new IllegalStateException("The readMethod (%s) must have a non-void return type."
.formatted(methodName));
}
}
}
/**
* Asserts method is a getter or read method
*
* @param method Method to assert is getter or read
* @param returnTypeRequired Flag used to check method return type
* @param annotationClass Used in exception message
*/
private static void assertIsGoodMethod(MethodDescriptor method, boolean returnTypeRequired,
Class<? extends Annotation> annotationClass) {
// V = void return type
// Z = primitive boolean return type
String methodName = method.getName();
if (method.getParameterTypes().length != 0) {
// not read or getter method
throw new IllegalStateException(
"The getterMethod (%s) with a %s annotation must not have any parameters, but has parameters (%s)."
.formatted(methodName, annotationClass.getSimpleName(),
Arrays.toString(method.getParameterTypes())));
}
if (methodName.startsWith("get")) {
if (method.getReturnType().equals("V")) {
throw new IllegalStateException("The getterMethod (%s) with a %s annotation must have a non-void return type."
.formatted(methodName, annotationClass.getSimpleName()));
}
} else if (methodName.startsWith("is")) {
if (!method.getReturnType().equals("Z")) {
throw new IllegalStateException("""
The getterMethod (%s) with a %s annotation must have a primitive boolean return type but returns (%s).
Maybe rename the method (get%s)?"""
.formatted(methodName, annotationClass.getSimpleName(), method.getReturnType(),
methodName.substring(2)));
}
} else {
// must be a read method and return a result only if returnTypeRequired is true
if (returnTypeRequired && method.getReturnType().equals("V")) {
throw new IllegalStateException("The readMethod (%s) with a %s annotation must have a non-void return type."
.formatted(methodName, annotationClass.getSimpleName()));
}
}
}
/**
* Generates the following code:
*
* <pre>
* String getName() {
* return "fieldOrMethodName";
* }
* </pre>
*
* If it is a getter method, "get" is removed and the first
* letter become lowercase
*/
private static void createGetName(ClassCreator classCreator, GizmoMemberInfo memberInfo) {
MethodCreator methodCreator = getMethodCreator(classCreator, String.class, "getName");
// If it is a method, assert that it has the required
// properties
memberInfo.descriptor().whenIsMethod(method -> {
var annotationClass = memberInfo.annotationClass();
if (annotationClass == null) {
assertIsGoodMethod(method, memberInfo.returnTypeRequired());
} else {
assertIsGoodMethod(method, memberInfo.returnTypeRequired(), annotationClass);
}
});
String fieldName = memberInfo.descriptor().getName();
ResultHandle out = methodCreator.load(fieldName);
methodCreator.returnValue(out);
}
/**
* Generates the following code:
*
* <pre>
* Class getType() {
* return FieldTypeOrMethodReturnType.class;
* }
* </pre>
*/
private static void createGetType(ClassCreator classCreator, GizmoMemberInfo memberInfo) {
MethodCreator methodCreator = getMethodCreator(classCreator, Class.class, "getType");
ResultHandle out = methodCreator.loadClass(memberInfo.descriptor().getTypeName());
methodCreator.returnValue(out);
}
/**
* Generates the following code:
*
* <pre>
* Type getGenericType() {
* return GizmoMemberAccessorImplementor.getGenericTypeFor(this.getClass().getName());
* }
* </pre>
*
* We are unable to load a non-primitive object constant, so we need to store it
* in the implementor, which then can return us the Type when needed. The type
* is stored in gizmoMemberAccessorNameToGenericType when this method is called.
*/
private static void createGetGenericType(ClassCreator classCreator) {
MethodCreator methodCreator = getMethodCreator(classCreator, Type.class, "getGenericType");
ResultHandle thisObj = methodCreator.getThis();
ResultHandle out =
methodCreator.readInstanceField(FieldDescriptor.of(classCreator.getClassName(), GENERIC_TYPE_FIELD, Type.class),
thisObj);
methodCreator.returnValue(out);
}
/**
* Generates the following code:
*
* For a field
*
* <pre>
* Object executeGetter(Object bean) {
* return ((DeclaringClass) bean).field;
* }
* </pre>
*
* For a method with returning type
*
* <pre>
* Object executeGetter(Object bean) {
* return ((DeclaringClass) bean).method();
* }
* </pre>
*
* For a method without returning type
*
* <pre>
* Object executeGetter(Object bean) {
* ((DeclaringClass) bean).method();
* return null;
* }
* </pre>
*
* The member MUST be public if not called in Quarkus
* (i.e. we don't delegate to the field getter/setter).
* In Quarkus, we generate simple getter/setter for the
* member if it is private (which get passed to the MemberDescriptor).
*/
private static void createExecuteGetter(ClassCreator classCreator, GizmoMemberInfo memberInfo) {
MethodCreator methodCreator = getMethodCreator(classCreator, Object.class, "executeGetter", Object.class);
ResultHandle bean = methodCreator.getMethodParam(0);
if (memberInfo.returnTypeRequired()) {
methodCreator.returnValue(memberInfo.descriptor().readMemberValue(methodCreator, bean));
} else {
memberInfo.descriptor().readMemberValue(methodCreator, bean);
// Returns null as the called method has no return type
methodCreator.returnNull();
}
}
/**
* Generates the following code:
*
* For a field
*
* <pre>
* void executeSetter(Object bean, Object value) {
* return ((DeclaringClass) bean).field = value;
* }
* </pre>
*
* For a getter method with a corresponding setter
*
* <pre>
* void executeSetter(Object bean, Object value) {
* return ((DeclaringClass) bean).setValue(value);
* }
* </pre>
*
* For a read method or a getter method without a setter
*
* <pre>
* void executeSetter(Object bean, Object value) {
* throw new UnsupportedOperationException("Setter not supported");
* }
* </pre>
*/
private static void createExecuteSetter(ClassCreator classCreator, GizmoMemberInfo memberInfo) {
MethodCreator methodCreator = getMethodCreator(classCreator, void.class, "executeSetter", Object.class,
Object.class);
ResultHandle bean = methodCreator.getMethodParam(0);
ResultHandle value = methodCreator.getMethodParam(1);
if (memberInfo.descriptor().writeMemberValue(methodCreator, bean, value)) {
// we are here only if the write is successful
methodCreator.returnValue(null);
} else {
methodCreator.throwException(UnsupportedOperationException.class, "Setter not supported");
}
}
private static MethodCreator getAnnotationMethodCreator(ClassCreator classCreator, Class<?> returnType, String methodName,
Class<?>... parameters) {
return classCreator.getMethodCreator(getAnnotationMethod(returnType, methodName, parameters));
}
private static MethodDescriptor getAnnotationMethod(Class<?> returnType, String methodName, Class<?>... parameters) {
return MethodDescriptor.ofMethod(AnnotatedElement.class, methodName, returnType, parameters);
}
/**
* Generates the following code:
*
* <pre>
* Object getAnnotation(Class annotationClass) {
* AnnotatedElement annotatedElement = GizmoMemberAccessorImplementor
* .getAnnotatedElementFor(this.getClass().getName());
* return annotatedElement.getAnnotation(annotationClass);
* }
* </pre>
*/
private static void createGetAnnotation(ClassCreator classCreator) {
MethodCreator methodCreator = getAnnotationMethodCreator(classCreator, Annotation.class, "getAnnotation", Class.class);
ResultHandle thisObj = methodCreator.getThis();
ResultHandle annotatedElement = methodCreator.readInstanceField(
FieldDescriptor.of(classCreator.getClassName(), ANNOTATED_ELEMENT_FIELD, AnnotatedElement.class),
thisObj);
ResultHandle query = methodCreator.getMethodParam(0);
ResultHandle out =
methodCreator.invokeInterfaceMethod(getAnnotationMethod(Annotation.class, "getAnnotation", Class.class),
annotatedElement, query);
methodCreator.returnValue(out);
}
private static void createDeclaredAnnotationsByType(ClassCreator classCreator) {
MethodCreator methodCreator =
getAnnotationMethodCreator(classCreator, Annotation[].class, "getDeclaredAnnotationsByType", Class.class);
ResultHandle thisObj = methodCreator.getThis();
ResultHandle annotatedElement = methodCreator.readInstanceField(
FieldDescriptor.of(classCreator.getClassName(), ANNOTATED_ELEMENT_FIELD, AnnotatedElement.class),
thisObj);
ResultHandle query = methodCreator.getMethodParam(0);
ResultHandle out = methodCreator.invokeInterfaceMethod(
getAnnotationMethod(Annotation[].class, "getDeclaredAnnotationsByType", Class.class),
annotatedElement, query);
methodCreator.returnValue(out);
}
private GizmoMemberAccessorImplementor() {
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoMemberDescriptor.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.Optional;
import java.util.function.Consumer;
import ai.timefold.solver.core.impl.domain.common.ReflectionHelper;
import io.quarkus.gizmo.BytecodeCreator;
import io.quarkus.gizmo.FieldDescriptor;
import io.quarkus.gizmo.MethodDescriptor;
import io.quarkus.gizmo.ResultHandle;
/**
* Describe and provide simplified/unified access for {@link Member}.
*/
public final class GizmoMemberDescriptor {
/**
* The name of a member.
* For a field, it is the field name.
* For a method,
* if it is a getter, the method name without "get"/"is" and the first letter lowercase;
* otherwise, the method name.
*/
private final String name;
private final GizmoMemberHandler memberHandler;
/**
* Should only be used for metadata (i.e. Generic Type and Annotated Element).
*/
private final GizmoMemberHandler metadataHandler;
/**
* The MethodDescriptor of the corresponding setter. Empty if not present.
*/
private final MethodDescriptor setter;
public GizmoMemberDescriptor(Member member) {
Class<?> declaringClass = member.getDeclaringClass();
if (!Modifier.isPublic(member.getModifiers())) {
throw new IllegalStateException("Member (" + member.getName() + ") of class (" +
member.getDeclaringClass().getName() + ") is not public and domainAccessType is GIZMO.\n" +
((member instanceof Field) ? "Maybe put the annotations onto the public getter of the field.\n" : "") +
"Maybe use domainAccessType REFLECTION instead of GIZMO.");
}
if (member instanceof Field field) {
FieldDescriptor fieldDescriptor = FieldDescriptor.of(field);
this.name = member.getName();
this.memberHandler = GizmoMemberHandler.of(declaringClass, name, fieldDescriptor, false);
this.setter = null;
} else if (member instanceof Method method) {
MethodDescriptor methodDescriptor = MethodDescriptor.ofMethod(method);
this.name = ReflectionHelper.isGetterMethod(method) ? ReflectionHelper.getGetterPropertyName(member)
: member.getName();
this.memberHandler = GizmoMemberHandler.of(declaringClass, methodDescriptor);
this.setter = lookupSetter(methodDescriptor, declaringClass, name).orElse(null);
} else {
throw new IllegalArgumentException(member + " is not a Method or a Field.");
}
this.metadataHandler = this.memberHandler;
}
public GizmoMemberDescriptor(String name, FieldDescriptor fieldDescriptor, Class<?> declaringClass) {
this.name = name;
this.memberHandler = GizmoMemberHandler.of(declaringClass, name, fieldDescriptor, true);
this.metadataHandler = this.memberHandler;
this.setter = null;
}
public GizmoMemberDescriptor(String name, MethodDescriptor memberDescriptor, MethodDescriptor metadataDescriptor,
Class<?> declaringClass, MethodDescriptor setterDescriptor) {
this.name = name;
this.memberHandler = GizmoMemberHandler.of(declaringClass, memberDescriptor);
this.metadataHandler = memberDescriptor == metadataDescriptor ? this.memberHandler
: GizmoMemberHandler.of(declaringClass, metadataDescriptor);
this.setter = setterDescriptor;
}
public GizmoMemberDescriptor(String name, MethodDescriptor memberDescriptor, Class<?> declaringClass,
MethodDescriptor setterDescriptor) {
this.name = name;
this.memberHandler = GizmoMemberHandler.of(declaringClass, memberDescriptor);
this.metadataHandler = this.memberHandler;
this.setter = setterDescriptor;
}
public GizmoMemberDescriptor(String name, MethodDescriptor memberDescriptor, FieldDescriptor metadataDescriptor,
Class<?> declaringClass, MethodDescriptor setterDescriptor) {
this.name = name;
this.memberHandler = GizmoMemberHandler.of(declaringClass, memberDescriptor);
this.metadataHandler = GizmoMemberHandler.of(declaringClass, name, metadataDescriptor, true);
this.setter = setterDescriptor;
}
/**
* If the member accessor is a field, pass the member's field descriptor to the
* provided consumer. Otherwise, do nothing. Returns self for chaining.
*
* @param fieldDescriptorConsumer What to do if the member a field.
* @return this
*/
public GizmoMemberDescriptor whenIsField(Consumer<FieldDescriptor> fieldDescriptorConsumer) {
memberHandler.whenIsField(fieldDescriptorConsumer);
return this;
}
/**
* If the member accessor is a method, pass the member's method descriptor to the
* provided consumer. Otherwise, do nothing. Returns self for chaining.
*
* @param methodDescriptorConsumer What to do if the member a method.
* @return this
*/
public GizmoMemberDescriptor whenIsMethod(Consumer<MethodDescriptor> methodDescriptorConsumer) {
memberHandler.whenIsMethod(methodDescriptorConsumer);
return this;
}
public ResultHandle readMemberValue(BytecodeCreator bytecodeCreator, ResultHandle thisObj) {
return memberHandler.readMemberValue(bytecodeCreator, thisObj);
}
/**
* Write the bytecode for writing to this member. If there is no setter,
* it write the bytecode for throwing the exception. Return true if
* it was able to write the member value.
*
* @param bytecodeCreator the bytecode creator to use
* @param thisObj the bean to write the new value to
* @param newValue to new value of the member
* @return True if it was able to write the member value, false otherwise
*/
public boolean writeMemberValue(BytecodeCreator bytecodeCreator, ResultHandle thisObj, ResultHandle newValue) {
return memberHandler.writeMemberValue(setter, bytecodeCreator, thisObj, newValue);
}
/**
* If the member metadata is on a field, pass the member's field descriptor to the
* provided consumer. Otherwise, do nothing. Returns self for chaining.
*
* @param fieldDescriptorConsumer What to do if the member a field.
* @return this
*/
public GizmoMemberDescriptor whenMetadataIsOnField(Consumer<FieldDescriptor> fieldDescriptorConsumer) {
metadataHandler.whenIsField(fieldDescriptorConsumer);
return this;
}
/**
* If the member metadata is on a method, pass the member's method descriptor to the
* provided consumer. Otherwise, do nothing. Returns self for chaining.
*
* @param methodDescriptorConsumer What to do if the member a method.
* @return this
*/
public GizmoMemberDescriptor whenMetadataIsOnMethod(Consumer<MethodDescriptor> methodDescriptorConsumer) {
metadataHandler.whenIsMethod(methodDescriptorConsumer);
return this;
}
/**
* Returns the declaring class name of the member in descriptor format.
* For instance, the declaring class name of Object.toString() is "java/lang/Object".
*
* @return Returns the declaring class name of the member in descriptor format
*/
public String getDeclaringClassName() {
return memberHandler.getDeclaringClassName();
}
public Optional<MethodDescriptor> getSetter() {
return Optional.ofNullable(setter);
}
private static Optional<MethodDescriptor> lookupSetter(Object memberDescriptor, Class<?> declaringClass, String name) {
if (memberDescriptor instanceof MethodDescriptor) {
return Optional.ofNullable(ReflectionHelper.getSetterMethod(declaringClass, name))
.map(MethodDescriptor::ofMethod);
} else {
return Optional.empty();
}
}
public String getName() {
return name;
}
/**
* Returns the member type (for fields) / return type (for methods) name.
* The name does not include generic information.
*/
public String getTypeName() {
String typeName = metadataHandler.getTypeName();
return org.objectweb.asm.Type.getType(typeName).getClassName();
}
public Type getType() {
return metadataHandler.getType();
}
@Override
public String toString() {
return memberHandler.toString();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoMemberHandler.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.lang.reflect.Field;
import java.lang.reflect.Method;
import java.lang.reflect.Modifier;
import java.lang.reflect.Type;
import java.util.function.Consumer;
import io.quarkus.gizmo.BytecodeCreator;
import io.quarkus.gizmo.FieldDescriptor;
import io.quarkus.gizmo.MethodDescriptor;
import io.quarkus.gizmo.ResultHandle;
interface GizmoMemberHandler {
/**
* Creates handler for a {@link Field}.
*
* @param declaringClass never null, class that declares the {@link Field} in question
* @param name never null, name of the field
* @param fieldDescriptor never null, descriptor of the {@link Field} in question
* @param ignoreFinalChecks true if Quarkus will make the field non-final for us
* @return never null
*/
static GizmoMemberHandler of(Class<?> declaringClass, String name, FieldDescriptor fieldDescriptor,
boolean ignoreFinalChecks) {
try {
Field field = declaringClass.getField(name);
return new GizmoFieldHandler(declaringClass, fieldDescriptor,
ignoreFinalChecks || !Modifier.isFinal(field.getModifiers()));
} catch (NoSuchFieldException e) { // The field is only used for its metadata and never actually called.
return new GizmoFieldHandler(declaringClass, fieldDescriptor, false);
}
}
/**
* Creates handler for a {@link Method}.
*
* @param declaringClass never null, class that declares the {@link Method} in question
* @param methodDescriptor never null, descriptor of the {@link Method} in question
* @return never null
*/
static GizmoMemberHandler of(Class<?> declaringClass, MethodDescriptor methodDescriptor) {
return new GizmoMethodHandler(declaringClass, methodDescriptor);
}
void whenIsField(Consumer<FieldDescriptor> fieldDescriptorConsumer);
void whenIsMethod(Consumer<MethodDescriptor> methodDescriptorConsumer);
ResultHandle readMemberValue(BytecodeCreator bytecodeCreator, ResultHandle thisObj);
boolean writeMemberValue(MethodDescriptor setter, BytecodeCreator bytecodeCreator, ResultHandle thisObj,
ResultHandle newValue);
String getDeclaringClassName();
String getTypeName();
Type getType();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoMemberInfo.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.lang.annotation.Annotation;
/**
* @param descriptor never null
* @param returnTypeRequired true if the method return type is required
* @param annotationClass null if not annotated
*/
public record GizmoMemberInfo(GizmoMemberDescriptor descriptor, boolean returnTypeRequired,
Class<? extends Annotation> annotationClass) {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/common/accessor/gizmo/GizmoMethodHandler.java | package ai.timefold.solver.core.impl.domain.common.accessor.gizmo;
import java.lang.reflect.Type;
import java.util.function.Consumer;
import io.quarkus.gizmo.BytecodeCreator;
import io.quarkus.gizmo.FieldDescriptor;
import io.quarkus.gizmo.MethodDescriptor;
import io.quarkus.gizmo.ResultHandle;
final class GizmoMethodHandler implements GizmoMemberHandler {
private final Class<?> declaringClass;
private final MethodDescriptor methodDescriptor;
GizmoMethodHandler(Class<?> declaringClass, MethodDescriptor methodDescriptor) {
this.declaringClass = declaringClass;
this.methodDescriptor = methodDescriptor;
}
@Override
public void whenIsField(Consumer<FieldDescriptor> fieldDescriptorConsumer) {
// Do nothing,
}
@Override
public void whenIsMethod(Consumer<MethodDescriptor> methodDescriptorConsumer) {
methodDescriptorConsumer.accept(methodDescriptor);
}
@Override
public ResultHandle readMemberValue(BytecodeCreator bytecodeCreator, ResultHandle thisObj) {
return invokeMemberMethod(declaringClass, bytecodeCreator, methodDescriptor, thisObj);
}
@Override
public boolean writeMemberValue(MethodDescriptor setter, BytecodeCreator bytecodeCreator, ResultHandle thisObj,
ResultHandle newValue) {
if (setter == null) {
return false;
} else {
invokeMemberMethod(declaringClass, bytecodeCreator, setter, thisObj, newValue);
return true;
}
}
private ResultHandle invokeMemberMethod(Class<?> declaringClass, BytecodeCreator creator, MethodDescriptor method,
ResultHandle bean, ResultHandle... parameters) {
if (declaringClass.isInterface()) {
return creator.invokeInterfaceMethod(method, bean, parameters);
} else {
return creator.invokeVirtualMethod(method, bean, parameters);
}
}
@Override
public String getDeclaringClassName() {
return methodDescriptor.getDeclaringClass();
}
@Override
public String getTypeName() {
return methodDescriptor.getReturnType();
}
@Override
public Type getType() {
try {
return declaringClass.getDeclaredMethod(methodDescriptor.getName()).getGenericReturnType();
} catch (NoSuchMethodException e) {
throw new IllegalStateException(
"Cannot find method (" + methodDescriptor.getName() + ") on class (" + declaringClass + ").",
e);
}
}
@Override
public String toString() {
return methodDescriptor.toString();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/entity | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/domain/entity/descriptor/EntityDescriptor.java | package ai.timefold.solver.core.impl.domain.entity.descriptor;
import static ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessorFactory.MemberAccessorType.FIELD_OR_GETTER_METHOD_WITH_SETTER;
import static ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessorFactory.MemberAccessorType.FIELD_OR_READ_METHOD;
import static ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptorValidator.assertNotMixedInheritance;
import static ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptorValidator.assertSingleInheritance;
import static ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptorValidator.assertValidPlanningVariables;
import static ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptorValidator.isEntityClass;
import java.lang.annotation.Annotation;
import java.lang.reflect.AnnotatedElement;
import java.lang.reflect.Field;
import java.lang.reflect.Member;
import java.lang.reflect.Method;
import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.function.BiPredicate;
import java.util.function.Consumer;
import java.util.function.Predicate;
import ai.timefold.solver.core.api.domain.entity.PinningFilter;
import ai.timefold.solver.core.api.domain.entity.PlanningEntity;
import ai.timefold.solver.core.api.domain.entity.PlanningPin;
import ai.timefold.solver.core.api.domain.entity.PlanningPinToIndex;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.domain.valuerange.ValueRangeProvider;
import ai.timefold.solver.core.api.domain.variable.AnchorShadowVariable;
import ai.timefold.solver.core.api.domain.variable.CascadingUpdateShadowVariable;
import ai.timefold.solver.core.api.domain.variable.CustomShadowVariable;
import ai.timefold.solver.core.api.domain.variable.IndexShadowVariable;
import ai.timefold.solver.core.api.domain.variable.InverseRelationShadowVariable;
import ai.timefold.solver.core.api.domain.variable.NextElementShadowVariable;
import ai.timefold.solver.core.api.domain.variable.PiggybackShadowVariable;
import ai.timefold.solver.core.api.domain.variable.PlanningListVariable;
import ai.timefold.solver.core.api.domain.variable.PlanningVariable;
import ai.timefold.solver.core.api.domain.variable.PreviousElementShadowVariable;
import ai.timefold.solver.core.api.domain.variable.ShadowVariable;
import ai.timefold.solver.core.api.domain.variable.ShadowVariablesInconsistent;
import ai.timefold.solver.core.config.heuristic.selector.common.decorator.SelectionSorterOrder;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.impl.domain.common.ReflectionHelper;
import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
import ai.timefold.solver.core.impl.domain.policy.DescriptorPolicy;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.domain.valuerange.descriptor.CompositeValueRangeDescriptor;
import ai.timefold.solver.core.impl.domain.variable.anchor.AnchorShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.cascade.CascadingUpdateShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.custom.CustomShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.custom.LegacyCustomShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.custom.PiggybackShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.DeclarativeShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.ShadowVariablesInconsistentVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.BasicVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.GenuineVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.VariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.index.IndexShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.inverserelation.InverseRelationShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.nextprev.NextElementShadowVariableDescriptor;
import ai.timefold.solver.core.impl.domain.variable.nextprev.PreviousElementShadowVariableDescriptor;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.ComparatorSelectionSorter;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionSorter;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.WeightFactorySelectionSorter;
import ai.timefold.solver.core.impl.move.director.MoveDirector;
import ai.timefold.solver.core.impl.move.streams.maybeapi.UniDataFilter;
import ai.timefold.solver.core.impl.util.CollectionUtils;
import ai.timefold.solver.core.impl.util.MutableInt;
import ai.timefold.solver.core.preview.api.domain.metamodel.PlanningEntityMetaModel;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class EntityDescriptor<Solution_> {
protected static final Class[] VARIABLE_ANNOTATION_CLASSES = {
PlanningVariable.class,
PlanningListVariable.class,
InverseRelationShadowVariable.class,
AnchorShadowVariable.class,
IndexShadowVariable.class,
PreviousElementShadowVariable.class,
NextElementShadowVariable.class,
ShadowVariable.class,
ShadowVariable.List.class,
PiggybackShadowVariable.class,
CustomShadowVariable.class,
CascadingUpdateShadowVariable.class,
ShadowVariablesInconsistent.class
};
private static final Logger LOGGER = LoggerFactory.getLogger(EntityDescriptor.class);
private final int ordinal;
private final SolutionDescriptor<Solution_> solutionDescriptor;
private final Class<?> entityClass;
private final List<Class<?>> declaredInheritedEntityClassList = new ArrayList<>();
private final Predicate<Object> isInitializedPredicate;
private final List<MemberAccessor> declaredPlanningPinIndexMemberAccessorList = new ArrayList<>();
@Nullable
private ShadowVariablesInconsistentVariableDescriptor<Solution_> shadowVariablesInconsistentDescriptor;
// Only declared movable filter, excludes inherited and descending movable filters
private MovableFilter<Solution_> declaredMovableEntityFilter;
private SelectionSorter<Solution_, Object> decreasingDifficultySorter;
// Only declared variable descriptors, excludes inherited variable descriptors
private Map<String, GenuineVariableDescriptor<Solution_>> declaredGenuineVariableDescriptorMap;
private Map<String, ShadowVariableDescriptor<Solution_>> declaredShadowVariableDescriptorMap;
private Map<String, CascadingUpdateShadowVariableDescriptor<Solution_>> declaredCascadingUpdateShadowVariableDecriptorMap;
private List<MovableFilter<Solution_>> declaredPinEntityFilterList;
private List<EntityDescriptor<Solution_>> effectiveInheritedEntityDescriptorList;
// Caches the inherited, declared and descending movable filters (including @PlanningPin filters) as a composite filter
private MovableFilter<Solution_> effectiveMovableEntityFilter;
private PlanningPinToIndexReader effectivePlanningPinToIndexReader;
// Caches the inherited and declared variable descriptors
private Map<String, GenuineVariableDescriptor<Solution_>> effectiveGenuineVariableDescriptorMap;
private Map<String, ShadowVariableDescriptor<Solution_>> effectiveShadowVariableDescriptorMap;
private Map<String, VariableDescriptor<Solution_>> effectiveVariableDescriptorMap;
// Duplicate of effectiveGenuineVariableDescriptorMap.values() for faster iteration on the hot path.
private List<GenuineVariableDescriptor<Solution_>> effectiveGenuineVariableDescriptorList;
private List<ListVariableDescriptor<Solution_>> effectiveGenuineListVariableDescriptorList;
private final UniDataFilter<Solution_, Object> entityMovablePredicate =
(solutionView, entity) -> {
var moveDirector = (MoveDirector<Solution_, ?>) solutionView;
return !moveDirector.isPinned(this, entity);
};
// Caches the metamodel
private PlanningEntityMetaModel<Solution_, ?> entityMetaModel = null;
// Caches the for each predicates
private EntityForEachFilter entityForEachFilter = null;
// ************************************************************************
// Constructors and simple getters/setters
// ************************************************************************
public EntityDescriptor(int ordinal, SolutionDescriptor<Solution_> solutionDescriptor, Class<?> entityClass) {
this.ordinal = ordinal;
SolutionDescriptor.assertMutable(entityClass, "entityClass");
this.solutionDescriptor = solutionDescriptor;
this.entityClass = entityClass;
this.declaredInheritedEntityClassList.addAll(extractInheritedClasses(entityClass));
isInitializedPredicate = this::isInitialized;
if (entityClass.getPackage() == null) {
LOGGER.warn("The entityClass ({}) should be in a proper java package.", entityClass);
}
}
@SuppressWarnings("unchecked")
public static Collection<Class<? extends Annotation>> getVariableAnnotationClasses() {
return List.of(VARIABLE_ANNOTATION_CLASSES);
}
/**
* A number unique within a {@link SolutionDescriptor}, increasing sequentially from zero.
* Used for indexing in arrays to avoid object hash lookups in maps.
*
* @return zero or higher
*/
public int getOrdinal() {
return ordinal;
}
/**
* Using entityDescriptor::isInitialized directly breaks node sharing
* because it creates multiple instances of this {@link Predicate}.
*
* @deprecated Prefer {@link #getEntityForEachFilter()} ()}.
* @return never null, always the same {@link Predicate} instance to {@link #isInitialized(Object)}
*/
@Deprecated(forRemoval = true)
public Predicate<Object> getIsInitializedPredicate() {
return isInitializedPredicate;
}
public EntityForEachFilter getEntityForEachFilter() {
if (entityForEachFilter == null) {
entityForEachFilter = new EntityForEachFilter(this);
}
return entityForEachFilter;
}
// ************************************************************************
// Lifecycle methods
// ************************************************************************
public void processAnnotations(DescriptorPolicy descriptorPolicy) {
processEntityAnnotations();
declaredGenuineVariableDescriptorMap = new LinkedHashMap<>();
declaredShadowVariableDescriptorMap = new LinkedHashMap<>();
declaredCascadingUpdateShadowVariableDecriptorMap = new HashMap<>();
declaredPinEntityFilterList = new ArrayList<>(2);
// Only iterate declared fields and methods, not inherited members, to avoid registering the same one twice
// The inherited classes will be analyzed in a later step
var memberList = ConfigUtils.getDeclaredMembers(entityClass);
var variableDescriptorCounter = new MutableInt(0);
for (var member : memberList) {
processValueRangeProviderAnnotation(descriptorPolicy, member);
processPlanningVariableAnnotation(variableDescriptorCounter, descriptorPolicy, member);
processPlanningPinAnnotation(descriptorPolicy, member);
}
// Verify that there are no defined planning variables from annotated or inherited classes
if (declaredGenuineVariableDescriptorMap.isEmpty() && declaredShadowVariableDescriptorMap.isEmpty()
&& declaredInheritedEntityClassList.isEmpty()) {
throw new IllegalStateException(
"The entityClass (%s) should have at least 1 getter method or 1 field with a %s annotation or a shadow variable annotation."
.formatted(entityClass, PlanningVariable.class.getSimpleName()));
}
processVariableAnnotations(descriptorPolicy);
}
private void processEntityAnnotations() {
assertNotMixedInheritance(entityClass, declaredInheritedEntityClassList);
assertSingleInheritance(entityClass, declaredInheritedEntityClassList);
assertValidPlanningVariables(entityClass);
var entityAnnotation = entityClass.getAnnotation(PlanningEntity.class);
if (entityAnnotation == null && declaredInheritedEntityClassList.isEmpty()) {
throw new IllegalStateException(
"The entityClass (%s) has been specified as a planning entity in the configuration, but does not have a @%s annotation."
.formatted(entityClass, PlanningEntity.class.getSimpleName()));
}
// We use the parent class of the entity as the base annotation
if (entityAnnotation == null) {
entityAnnotation = declaredInheritedEntityClassList.stream().filter(c -> !c.equals(entityClass))
.findFirst()
.map(c -> c.getAnnotation(PlanningEntity.class))
.orElseThrow(
() -> new IllegalStateException("Impossible state as the previous if block would fail first."));
}
processMovable(entityAnnotation);
processDifficulty(entityAnnotation);
}
/**
* @deprecated Remove in the next major version of Timefold Solver.
*/
@Deprecated(forRemoval = true, since = "1.23.0")
private void processMovable(PlanningEntity entityAnnotation) {
if (entityAnnotation == null) {
return;
}
var pinningFilterClass = entityAnnotation.pinningFilter();
var hasPinningFilter = pinningFilterClass != PlanningEntity.NullPinningFilter.class;
if (hasPinningFilter) {
var pinningFilter = ConfigUtils.newInstance(this::toString, "pinningFilterClass",
(Class<? extends PinningFilter<Solution_, Object>>) pinningFilterClass);
declaredMovableEntityFilter = (solution, selection) -> !pinningFilter.accept(solution, selection);
}
}
private void processDifficulty(PlanningEntity entityAnnotation) {
if (entityAnnotation == null) {
return;
}
var difficultyComparatorClass = entityAnnotation.difficultyComparatorClass();
if (difficultyComparatorClass == PlanningEntity.NullDifficultyComparator.class) {
difficultyComparatorClass = null;
}
var difficultyWeightFactoryClass = entityAnnotation.difficultyWeightFactoryClass();
if (difficultyWeightFactoryClass == PlanningEntity.NullDifficultyWeightFactory.class) {
difficultyWeightFactoryClass = null;
}
if (difficultyComparatorClass != null && difficultyWeightFactoryClass != null) {
throw new IllegalStateException(
"The entityClass (%s) cannot have a difficultyComparatorClass (%s) and a difficultyWeightFactoryClass (%s) at the same time."
.formatted(entityClass, difficultyComparatorClass.getName(),
difficultyWeightFactoryClass.getName()));
}
if (difficultyComparatorClass != null) {
var difficultyComparator = ConfigUtils.newInstance(this::toString,
"difficultyComparatorClass", difficultyComparatorClass);
decreasingDifficultySorter = new ComparatorSelectionSorter<>(
difficultyComparator, SelectionSorterOrder.DESCENDING);
}
if (difficultyWeightFactoryClass != null) {
var difficultyWeightFactory = ConfigUtils.newInstance(this::toString,
"difficultyWeightFactoryClass", difficultyWeightFactoryClass);
decreasingDifficultySorter = new WeightFactorySelectionSorter<>(
difficultyWeightFactory, SelectionSorterOrder.DESCENDING);
}
}
private void processValueRangeProviderAnnotation(DescriptorPolicy descriptorPolicy, Member member) {
if (((AnnotatedElement) member).isAnnotationPresent(ValueRangeProvider.class)) {
var memberAccessor = descriptorPolicy.getMemberAccessorFactory().buildAndCacheMemberAccessor(member,
FIELD_OR_READ_METHOD, ValueRangeProvider.class, descriptorPolicy.getDomainAccessType());
descriptorPolicy.addFromEntityValueRangeProvider(memberAccessor);
}
}
@SuppressWarnings("unchecked")
private void processPlanningVariableAnnotation(MutableInt variableDescriptorCounter, DescriptorPolicy descriptorPolicy,
Member member) {
var variableAnnotationClass = ConfigUtils.extractAnnotationClass(member, VARIABLE_ANNOTATION_CLASSES);
if (variableAnnotationClass != null) {
Object annotation;
if (member instanceof Field field) {
annotation = field.getAnnotation(variableAnnotationClass);
} else if (member instanceof Method method) {
annotation = method.getAnnotation(variableAnnotationClass);
} else {
throw new IllegalStateException("Member must be a field or a method, but was (%s)."
.formatted(member.getClass().getSimpleName()));
}
if (annotation == null) {
throw new IllegalStateException("Impossible state: cannot get annotation on a %s-annotated member (%s)."
.formatted(variableAnnotationClass, member));
}
var memberAccessor = descriptorPolicy.getMemberAccessorFactory()
.buildAndCacheMemberAccessor(member, FIELD_OR_GETTER_METHOD_WITH_SETTER, variableAnnotationClass,
descriptorPolicy.getDomainAccessType());
registerVariableAccessor(variableDescriptorCounter.intValue(), variableAnnotationClass, memberAccessor);
variableDescriptorCounter.increment();
}
}
private void registerVariableAccessor(int nextVariableDescriptorOrdinal,
Class<? extends Annotation> variableAnnotationClass, MemberAccessor memberAccessor) {
var memberName = memberAccessor.getName();
if (declaredGenuineVariableDescriptorMap.containsKey(memberName)
|| declaredShadowVariableDescriptorMap.containsKey(memberName)) {
VariableDescriptor<Solution_> duplicate = declaredGenuineVariableDescriptorMap.get(memberName);
if (duplicate == null) {
duplicate = declaredShadowVariableDescriptorMap.get(memberName);
}
throw new IllegalStateException("""
The entityClass (%s) has a @%s annotated member (%s), duplicated by member for variableDescriptor (%s).
Maybe the annotation is defined on both the field and its getter."""
.formatted(entityClass, variableAnnotationClass.getSimpleName(), memberAccessor, duplicate));
} else if (variableAnnotationClass.equals(PlanningVariable.class)) {
var type = memberAccessor.getType();
if (type.isArray()) {
throw new IllegalStateException("The entityClass (%s) has a @%s annotated member (%s) that is of an array type."
.formatted(entityClass, PlanningVariable.class.getSimpleName(), memberAccessor));
}
var variableDescriptor = new BasicVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredGenuineVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(PlanningListVariable.class)) {
if (List.class.isAssignableFrom(memberAccessor.getType())) {
var variableDescriptor = new ListVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredGenuineVariableDescriptorMap.put(memberName, variableDescriptor);
} else {
throw new IllegalStateException("""
The entityClass (%s) has a @%s annotated member (%s) that has an unsupported type (%s).
Maybe use %s."""
.formatted(entityClass, PlanningListVariable.class.getSimpleName(), memberAccessor,
memberAccessor.getType(), List.class.getCanonicalName()));
}
} else if (variableAnnotationClass.equals(InverseRelationShadowVariable.class)) {
var variableDescriptor =
new InverseRelationShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(AnchorShadowVariable.class)) {
var variableDescriptor = new AnchorShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(IndexShadowVariable.class)) {
var variableDescriptor = new IndexShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(PreviousElementShadowVariable.class)) {
var variableDescriptor =
new PreviousElementShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(NextElementShadowVariable.class)) {
var variableDescriptor =
new NextElementShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(ShadowVariable.class)
|| variableAnnotationClass.equals(ShadowVariable.List.class)) {
ShadowVariableDescriptor<Solution_> variableDescriptor;
var annotation = memberAccessor.getAnnotation(ShadowVariable.class);
if (annotation != null && !annotation.supplierName().isEmpty()) {
variableDescriptor =
new DeclarativeShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
} else {
variableDescriptor = new CustomShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
}
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(CascadingUpdateShadowVariable.class)) {
var variableDescriptor =
new CascadingUpdateShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
if (declaredCascadingUpdateShadowVariableDecriptorMap.containsKey(variableDescriptor.getTargetMethodName())) {
// If the target method is already set,
// it means that multiple fields define the cascading shadow variable
// and point to the same target method.
declaredCascadingUpdateShadowVariableDecriptorMap.get(variableDescriptor.getTargetMethodName())
.addTargetVariable(this, memberAccessor);
} else {
declaredCascadingUpdateShadowVariableDecriptorMap.put(variableDescriptor.getTargetMethodName(),
variableDescriptor);
}
} else if (variableAnnotationClass.equals(ShadowVariablesInconsistent.class)) {
var variableDescriptor = new ShadowVariablesInconsistentVariableDescriptor<>(nextVariableDescriptorOrdinal, this,
memberAccessor);
shadowVariablesInconsistentDescriptor = variableDescriptor;
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(PiggybackShadowVariable.class)) {
var variableDescriptor =
new PiggybackShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else if (variableAnnotationClass.equals(CustomShadowVariable.class)) {
var variableDescriptor =
new LegacyCustomShadowVariableDescriptor<>(nextVariableDescriptorOrdinal, this, memberAccessor);
declaredShadowVariableDescriptorMap.put(memberName, variableDescriptor);
} else {
throw new IllegalStateException("The variableAnnotationClass (%s) is not implemented."
.formatted(variableAnnotationClass));
}
}
private void processPlanningPinAnnotation(DescriptorPolicy descriptorPolicy, Member member) {
var annotatedMember = ((AnnotatedElement) member);
if (annotatedMember.isAnnotationPresent(PlanningPin.class)) {
var memberAccessor = descriptorPolicy.getMemberAccessorFactory().buildAndCacheMemberAccessor(member,
FIELD_OR_READ_METHOD, PlanningPin.class, descriptorPolicy.getDomainAccessType());
var type = memberAccessor.getType();
if (!Boolean.TYPE.isAssignableFrom(type) && !Boolean.class.isAssignableFrom(type)) {
throw new IllegalStateException(
"The entityClass (%s) has a %s annotated member (%s) that is not a boolean or Boolean."
.formatted(entityClass, PlanningPin.class.getSimpleName(), member));
}
declaredPinEntityFilterList.add(new PinEntityFilter<>(memberAccessor));
}
}
private void processPlanningPinIndexAnnotation(DescriptorPolicy descriptorPolicy, Member member) {
var annotatedMember = ((AnnotatedElement) member);
if (annotatedMember.isAnnotationPresent(PlanningPinToIndex.class)) {
if (!hasAnyGenuineListVariables()) {
throw new IllegalStateException(
"The entityClass (%s) has a %s annotated member (%s) but no %s annotated member."
.formatted(entityClass, PlanningPinToIndex.class.getSimpleName(), member,
PlanningListVariable.class.getSimpleName()));
}
var memberAccessor = descriptorPolicy.getMemberAccessorFactory().buildAndCacheMemberAccessor(member,
FIELD_OR_READ_METHOD, PlanningPinToIndex.class, descriptorPolicy.getDomainAccessType());
var type = memberAccessor.getType();
if (!Integer.TYPE.isAssignableFrom(type)) {
throw new IllegalStateException(
"The entityClass (%s) has a %s annotated member (%s) that is not a primitive int."
.formatted(entityClass, PlanningPinToIndex.class.getSimpleName(), member));
}
declaredPlanningPinIndexMemberAccessorList.add(memberAccessor);
}
}
private void processVariableAnnotations(DescriptorPolicy descriptorPolicy) {
for (var variableDescriptor : declaredGenuineVariableDescriptorMap.values()) {
variableDescriptor.processAnnotations(descriptorPolicy);
}
for (var variableDescriptor : declaredShadowVariableDescriptorMap.values()) {
variableDescriptor.processAnnotations(descriptorPolicy);
}
}
public void linkEntityDescriptors(DescriptorPolicy descriptorPolicy) {
investigateParentsToLinkInherited(entityClass);
createEffectiveVariableDescriptorMaps();
createEffectiveMovableEntitySelectionFilter();
// linkVariableDescriptors() is in a separate loop
}
private void investigateParentsToLinkInherited(Class<?> investigateClass) {
effectiveInheritedEntityDescriptorList = new ArrayList<>(4);
if (investigateClass == null || investigateClass.isArray()) {
return;
}
linkInherited(investigateClass.getSuperclass());
for (var superInterface : investigateClass.getInterfaces()) {
linkInherited(superInterface);
}
}
private void linkInherited(Class<?> potentialEntityClass) {
var entityDescriptor = solutionDescriptor.getEntityDescriptorStrict(potentialEntityClass);
if (entityDescriptor != null) {
effectiveInheritedEntityDescriptorList.add(entityDescriptor);
} else {
investigateParentsToLinkInherited(potentialEntityClass);
}
}
private void createEffectiveVariableDescriptorMaps() {
effectiveGenuineVariableDescriptorMap = new LinkedHashMap<>(declaredGenuineVariableDescriptorMap.size());
effectiveShadowVariableDescriptorMap = new LinkedHashMap<>(declaredShadowVariableDescriptorMap.size());
for (var inheritedEntityDescriptor : effectiveInheritedEntityDescriptorList) {
// We add all inherited variables from the parent classes
effectiveGenuineVariableDescriptorMap.putAll(inheritedEntityDescriptor.effectiveGenuineVariableDescriptorMap);
effectiveShadowVariableDescriptorMap.putAll(inheritedEntityDescriptor.effectiveShadowVariableDescriptorMap);
}
// It is not allowed to redefine genuine or shadow variables
var redefinedGenuineVariables = declaredGenuineVariableDescriptorMap.keySet().stream()
.filter(key -> effectiveGenuineVariableDescriptorMap.containsKey(key))
.toList();
if (!redefinedGenuineVariables.isEmpty()) {
throw new IllegalStateException("""
The class (%s) redefines the genuine variables (%s), which is not permitted.
Maybe remove the variables (%s) from the class (%s).""".formatted(entityClass,
redefinedGenuineVariables, String.join(", ", redefinedGenuineVariables),
entityClass));
}
effectiveGenuineVariableDescriptorMap.putAll(declaredGenuineVariableDescriptorMap);
var redefinedShadowVariables = declaredShadowVariableDescriptorMap.keySet().stream()
.filter(key -> effectiveShadowVariableDescriptorMap.containsKey(key))
.toList();
if (!redefinedShadowVariables.isEmpty()) {
throw new IllegalStateException("""
The class (%s) redefines the shadow variables (%s), which is not permitted.
Maybe remove the variables (%s) from the class (%s).""".formatted(entityClass,
redefinedShadowVariables, redefinedShadowVariables, entityClass));
}
effectiveShadowVariableDescriptorMap.putAll(declaredShadowVariableDescriptorMap);
effectiveVariableDescriptorMap = CollectionUtils
.newLinkedHashMap(effectiveGenuineVariableDescriptorMap.size() + effectiveShadowVariableDescriptorMap.size());
effectiveVariableDescriptorMap.putAll(effectiveGenuineVariableDescriptorMap);
effectiveVariableDescriptorMap.putAll(effectiveShadowVariableDescriptorMap);
effectiveGenuineVariableDescriptorList = new ArrayList<>(effectiveGenuineVariableDescriptorMap.values());
effectiveGenuineListVariableDescriptorList = effectiveGenuineVariableDescriptorList.stream()
.filter(VariableDescriptor::isListVariable)
.map(l -> (ListVariableDescriptor<Solution_>) l)
.toList();
}
private void createEffectiveMovableEntitySelectionFilter() {
if (declaredMovableEntityFilter != null && !hasAnyDeclaredGenuineVariableDescriptor()) {
throw new IllegalStateException(
"The entityClass (%s) has a movableEntitySelectionFilterClass (%s), but it has no declared genuine variables, only shadow variables."
.formatted(entityClass, declaredMovableEntityFilter.getClass()));
}
var movableFilterList = new ArrayList<MovableFilter<Solution_>>();
// TODO Also add in child entity selectors
for (var inheritedEntityDescriptor : effectiveInheritedEntityDescriptorList) {
if (inheritedEntityDescriptor.hasEffectiveMovableEntityFilter()) {
// Includes movable and pinned
movableFilterList.add(inheritedEntityDescriptor.effectiveMovableEntityFilter);
}
}
if (declaredMovableEntityFilter != null) {
movableFilterList.add(declaredMovableEntityFilter);
}
movableFilterList.addAll(declaredPinEntityFilterList);
if (movableFilterList.isEmpty()) {
effectiveMovableEntityFilter = null;
} else {
effectiveMovableEntityFilter = movableFilterList.stream()
.reduce(MovableFilter::and)
.orElseThrow(() -> new IllegalStateException("Impossible state: no movable filters."));
}
}
private void createEffectivePlanningPinIndexReader() {
if (!hasAnyGenuineListVariables()) {
effectivePlanningPinToIndexReader = null;
return;
}
var planningPinIndexMemberAccessorList = new ArrayList<MemberAccessor>();
for (var inheritedEntityDescriptor : effectiveInheritedEntityDescriptorList) {
if (inheritedEntityDescriptor.effectivePlanningPinToIndexReader != null) {
planningPinIndexMemberAccessorList.addAll(inheritedEntityDescriptor.declaredPlanningPinIndexMemberAccessorList);
}
}
planningPinIndexMemberAccessorList.addAll(declaredPlanningPinIndexMemberAccessorList);
switch (planningPinIndexMemberAccessorList.size()) {
case 0 -> effectivePlanningPinToIndexReader = null;
case 1 -> {
var memberAccessor = planningPinIndexMemberAccessorList.get(0);
effectivePlanningPinToIndexReader = entity -> (int) memberAccessor.executeGetter(entity);
}
default -> throw new IllegalStateException(
"The entityClass (%s) has (%d) @%s-annotated members (%s), where it should only have one."
.formatted(entityClass, planningPinIndexMemberAccessorList.size(),
PlanningPinToIndex.class.getSimpleName(), planningPinIndexMemberAccessorList));
}
}
public void linkVariableDescriptors(DescriptorPolicy descriptorPolicy) {
for (var variableDescriptor : declaredGenuineVariableDescriptorMap.values()) {
variableDescriptor.linkVariableDescriptors(descriptorPolicy);
}
for (var shadowVariableDescriptor : declaredShadowVariableDescriptorMap.values()) {
shadowVariableDescriptor.linkVariableDescriptors(descriptorPolicy);
}
/*
* We can only create the PlanningPinIndexReader after we have processed all list variable descriptors.
* Only iterate declared fields and methods, not inherited members,
* to avoid registering the same one twice.
*/
for (var member : ConfigUtils.getDeclaredMembers(entityClass)) {
processPlanningPinIndexAnnotation(descriptorPolicy, member);
}
createEffectivePlanningPinIndexReader();
}
// ************************************************************************
// Worker methods
// ************************************************************************
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return solutionDescriptor;
}
public Class<?> getEntityClass() {
return entityClass;
}
public boolean matchesEntity(Object entity) {
return entityClass.isAssignableFrom(entity.getClass());
}
public boolean hasPinningFilter() {
return declaredMovableEntityFilter != null;
}
public boolean hasEffectiveMovableEntityFilter() {
return effectiveMovableEntityFilter != null;
}
public boolean supportsPinning() {
return hasEffectiveMovableEntityFilter() || effectivePlanningPinToIndexReader != null;
}
public BiPredicate<Solution_, Object> getEffectiveMovableEntityFilter() {
return effectiveMovableEntityFilter;
}
@SuppressWarnings("unchecked")
public <A> UniDataFilter<Solution_, A> getEntityMovablePredicate() {
return (UniDataFilter<Solution_, A>) entityMovablePredicate;
}
public SelectionSorter<Solution_, Object> getDecreasingDifficultySorter() {
return decreasingDifficultySorter;
}
public Collection<String> getGenuineVariableNameSet() {
return effectiveGenuineVariableDescriptorMap.keySet();
}
public GenuineVariableDescriptor<Solution_> getGenuineVariableDescriptor(String variableName) {
return effectiveGenuineVariableDescriptorMap.get(variableName);
}
public @Nullable ShadowVariablesInconsistentVariableDescriptor<Solution_> getShadowVariablesInconsistentDescriptor() {
return shadowVariablesInconsistentDescriptor;
}
public boolean hasBothGenuineListAndBasicVariables() {
if (!isGenuine()) {
return false;
}
return hasAnyGenuineListVariables() && hasAnyGenuineBasicVariables();
}
public boolean hasAnyGenuineBasicVariables() {
if (!isGenuine()) {
return false;
}
return getDeclaredGenuineVariableDescriptors().stream()
.anyMatch(descriptor -> !descriptor.isListVariable());
}
public boolean hasAnyGenuineChainedVariables() {
if (!isGenuine()) {
return false;
}
return getDeclaredGenuineVariableDescriptors().stream()
.filter(descriptor -> descriptor instanceof BasicVariableDescriptor<Solution_>)
.map(descriptor -> (BasicVariableDescriptor<Solution_>) descriptor)
.anyMatch(BasicVariableDescriptor::isChained);
}
public boolean hasAnyGenuineListVariables() {
if (!isGenuine()) {
return false;
}
return getGenuineListVariableDescriptor() != null;
}
public boolean isGenuine() {
return !effectiveGenuineVariableDescriptorMap.isEmpty();
}
public ListVariableDescriptor<Solution_> getGenuineListVariableDescriptor() {
if (effectiveGenuineListVariableDescriptorList.isEmpty()) {
return null;
}
// Earlier validation guarantees there will only ever be one.
return effectiveGenuineListVariableDescriptorList.get(0);
}
public List<GenuineVariableDescriptor<Solution_>> getGenuineVariableDescriptorList() {
return effectiveGenuineVariableDescriptorList;
}
public List<GenuineVariableDescriptor<Solution_>> getGenuineBasicVariableDescriptorList() {
return effectiveGenuineVariableDescriptorList.stream()
.filter(descriptor -> !descriptor.isListVariable())
.toList();
}
public long getGenuineVariableCount() {
return effectiveGenuineVariableDescriptorList.size();
}
public int getValueRangeCount() {
var count = 0;
for (var genuineVariableDescriptor : effectiveGenuineVariableDescriptorList) {
if (genuineVariableDescriptor
.getValueRangeDescriptor() instanceof CompositeValueRangeDescriptor<Solution_> compositeValueRangeDescriptor) {
// sum the child descriptors size
// and add one more unit to the composite descriptor itself at the end of the iter
count += compositeValueRangeDescriptor.getValueRangeCount();
}
count++;
}
return count;
}
public Collection<ShadowVariableDescriptor<Solution_>> getShadowVariableDescriptors() {
return effectiveShadowVariableDescriptorMap.values();
}
public ShadowVariableDescriptor<Solution_> getShadowVariableDescriptor(String variableName) {
return effectiveShadowVariableDescriptorMap.get(variableName);
}
public Map<String, VariableDescriptor<Solution_>> getVariableDescriptorMap() {
return effectiveVariableDescriptorMap;
}
public boolean hasVariableDescriptor(String variableName) {
return effectiveVariableDescriptorMap.containsKey(variableName);
}
public @Nullable VariableDescriptor<Solution_> getVariableDescriptor(String variableName) {
return effectiveVariableDescriptorMap.get(variableName);
}
public @NonNull VariableDescriptor<Solution_> getVariableDescriptorOrFail(String variableName) {
var variableDescriptor = effectiveVariableDescriptorMap.get(variableName);
if (variableDescriptor == null) {
throw new IllegalArgumentException("""
Entity class %s does not hava a "%s" genuine or shadow variable.
Maybe you meant one of %s?"""
.formatted(entityClass.getSimpleName(),
variableName, effectiveVariableDescriptorMap.keySet()));
}
return variableDescriptor;
}
public boolean hasAnyDeclaredGenuineVariableDescriptor() {
return !declaredGenuineVariableDescriptorMap.isEmpty();
}
public Collection<GenuineVariableDescriptor<Solution_>> getDeclaredGenuineVariableDescriptors() {
return declaredGenuineVariableDescriptorMap.values();
}
public Collection<ShadowVariableDescriptor<Solution_>> getDeclaredShadowVariableDescriptors() {
return declaredShadowVariableDescriptorMap.values();
}
public Collection<CascadingUpdateShadowVariableDescriptor<Solution_>>
getDeclaredCascadingUpdateShadowVariableDescriptors() {
return declaredCascadingUpdateShadowVariableDecriptorMap.values();
}
public Collection<VariableDescriptor<Solution_>> getDeclaredVariableDescriptors() {
Collection<VariableDescriptor<Solution_>> variableDescriptors = new ArrayList<>(
declaredGenuineVariableDescriptorMap.size() + declaredShadowVariableDescriptorMap.size());
variableDescriptors.addAll(declaredGenuineVariableDescriptorMap.values());
variableDescriptors.addAll(declaredShadowVariableDescriptorMap.values());
return variableDescriptors;
}
public String buildInvalidVariableNameExceptionMessage(String variableName) {
if (!ReflectionHelper.hasGetterMethod(entityClass, variableName)
&& !ReflectionHelper.hasField(entityClass, variableName)) {
String exceptionMessage =
"""
The variableName (%s) for entityClass (%s) does not exist as a getter or field on that class.
Check the spelling of the variableName (%s)."""
.formatted(variableName, entityClass, variableName);
if (variableName.length() >= 2
&& !Character.isUpperCase(variableName.charAt(0))
&& Character.isUpperCase(variableName.charAt(1))) {
String correctedVariableName = variableName.substring(0, 1).toUpperCase() + variableName.substring(1);
exceptionMessage +=
"Maybe it needs to be correctedVariableName (%s) instead, if it's a getter, because the JavaBeans spec states that the first letter should be a upper case if the second is upper case."
.formatted(correctedVariableName);
}
return exceptionMessage;
}
return """
The variableName (%s) for entityClass (%s) exists as a getter or field on that class, but isn't in the planning variables (%s).
%sMaybe your planning entity's getter or field lacks a @%s annotation or a shadow variable annotation."""
.formatted(variableName, entityClass, effectiveVariableDescriptorMap.keySet(),
Character.isUpperCase(variableName.charAt(0))
? "Maybe the variableName (%s) should start with a lowercase.%n".formatted(variableName)
: "",
PlanningVariable.class.getSimpleName());
}
// ************************************************************************
// Extraction methods
// ************************************************************************
public static List<Class<?>> extractInheritedClasses(Class<?> entityClass) {
var entityClassList = new ArrayList<Class<?>>();
readParentEntityClassAnnotations(entityClass, entityClassList);
// We ensure the root child class is not present
return entityClassList.stream().filter(c -> !c.equals(entityClass)).toList();
}
private static void readParentEntityClassAnnotations(Class<?> entityClass, List<Class<?>> declaredEntityList) {
if (entityClass == null || entityClass.equals(Object.class)) {
return;
}
if (isEntityClass(entityClass)) {
declaredEntityList.add(entityClass);
}
readParentEntityClassAnnotations(entityClass.getSuperclass(), declaredEntityList);
for (var clazz : entityClass.getInterfaces()) {
readParentEntityClassAnnotations(clazz, declaredEntityList);
}
}
public List<Object> extractEntities(Solution_ solution) {
var entityList = new ArrayList<>();
visitAllEntities(solution, entityList::add);
return entityList;
}
public void visitAllEntities(Solution_ solution, Consumer<Object> visitor) {
solutionDescriptor.visitEntitiesByEntityClass(solution, entityClass, entity -> {
visitor.accept(entity);
return false; // Iterate over all entities.
});
}
public PlanningPinToIndexReader getEffectivePlanningPinToIndexReader() {
return effectivePlanningPinToIndexReader;
}
public int countUninitializedVariables(Object entity) {
var count = 0;
for (var variableDescriptor : effectiveGenuineVariableDescriptorList) {
if (!variableDescriptor.isInitialized(entity)) {
count++;
}
}
return count;
}
public boolean isInitialized(Object entity) {
for (var variableDescriptor : effectiveGenuineVariableDescriptorList) {
if (!variableDescriptor.isInitialized(entity)) {
return false;
}
}
return true;
}
public boolean hasNoNullVariables(Object entity) {
return switch (effectiveGenuineVariableDescriptorList.size()) { // Avoid excessive iterator allocation.
case 0 -> true;
case 1 -> effectiveGenuineVariableDescriptorList.get(0).getValue(entity) != null;
default -> {
for (var variableDescriptor : effectiveGenuineVariableDescriptorList) {
if (variableDescriptor.getValue(entity) == null) {
yield false;
}
}
yield true;
}
};
}
public int countReinitializableVariables(Object entity) {
var count = 0;
for (var variableDescriptor : effectiveGenuineVariableDescriptorList) {
if (variableDescriptor.isReinitializable(entity)) {
count++;
}
}
return count;
}
public boolean isMovable(Solution_ workingSolution, Object entity) {
return isGenuine() &&
(effectiveMovableEntityFilter == null
|| effectiveMovableEntityFilter.test(workingSolution, entity));
}
public PlanningEntityMetaModel<Solution_, ?> getEntityMetaModel() {
if (entityMetaModel != null) {
return entityMetaModel;
}
entityMetaModel = solutionDescriptor.getMetaModel()
.entity(entityClass);
return entityMetaModel;
}
@Override
public String toString() {
return "%s(%s)".formatted(getClass().getSimpleName(), entityClass.getName());
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.