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/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/quad/ToListQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.quad;
import java.util.List;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.collector.ListUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToListQuadCollector<A, B, C, D, Mapped_>
extends UndoableActionableQuadCollector<A, B, C, D, Mapped_, List<Mapped_>, ListUndoableActionable<Mapped_>> {
ToListQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<ListUndoableActionable<Mapped_>> supplier() {
return ListUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/quad/ToMultiMapQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.quad;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
final class ToMultiMapQuadCollector<A, B, C, D, Key_, Value_, Set_ extends Set<Value_>, Result_ extends Map<Key_, Set_>>
extends
UndoableActionableQuadCollector<A, B, C, D, Pair<Key_, Value_>, Result_, MapUndoableActionable<Key_, Value_, Set_, Result_>> {
private final QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Key_> keyFunction;
private final QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Value_> valueFunction;
private final Supplier<Result_> mapSupplier;
private final IntFunction<Set_> setFunction;
ToMultiMapQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Key_> keyFunction,
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
IntFunction<Set_> setFunction) {
super((a, b, c, d) -> new Pair<>(keyFunction.apply(a, b, c, d), valueFunction.apply(a, b, c, d)));
this.keyFunction = keyFunction;
this.valueFunction = valueFunction;
this.mapSupplier = mapSupplier;
this.setFunction = setFunction;
}
@Override
public @NonNull Supplier<MapUndoableActionable<Key_, Value_, Set_, Result_>> supplier() {
return () -> MapUndoableActionable.multiMap(mapSupplier, setFunction);
}
// Don't call super equals/hashCode; the groupingFunction is calculated from keyFunction
// and valueFunction
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ToMultiMapQuadCollector<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(keyFunction, that.keyFunction) && Objects.equals(valueFunction,
that.valueFunction) && Objects.equals(mapSupplier, that.mapSupplier)
&& Objects.equals(
setFunction, that.setFunction);
}
@Override
public int hashCode() {
return Objects.hash(keyFunction, valueFunction, mapSupplier, setFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/quad/ToSetQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.quad;
import java.util.Set;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.collector.SetUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToSetQuadCollector<A, B, C, D, Mapped_>
extends UndoableActionableQuadCollector<A, B, C, D, Mapped_, Set<Mapped_>, SetUndoableActionable<Mapped_>> {
ToSetQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<SetUndoableActionable<Mapped_>> supplier() {
return SetUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/quad/ToSimpleMapQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.quad;
import java.util.Map;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
final class ToSimpleMapQuadCollector<A, B, C, D, Key_, Value_, Result_ extends Map<Key_, Value_>>
extends
UndoableActionableQuadCollector<A, B, C, D, Pair<Key_, Value_>, Result_, MapUndoableActionable<Key_, Value_, Value_, Result_>> {
private final QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Key_> keyFunction;
private final QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Value_> valueFunction;
private final Supplier<Result_> mapSupplier;
private final BinaryOperator<Value_> mergeFunction;
ToSimpleMapQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Key_> keyFunction,
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
BinaryOperator<Value_> mergeFunction) {
super((a, b, c, d) -> new Pair<>(keyFunction.apply(a, b, c, d), valueFunction.apply(a, b, c, d)));
this.keyFunction = keyFunction;
this.valueFunction = valueFunction;
this.mapSupplier = mapSupplier;
this.mergeFunction = mergeFunction;
}
@Override
public @NonNull Supplier<MapUndoableActionable<Key_, Value_, Value_, Result_>> supplier() {
return () -> MapUndoableActionable.mergeMap(mapSupplier, mergeFunction);
}
// Don't call super equals/hashCode; the groupingFunction is calculated from keyFunction
// and valueFunction
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ToSimpleMapQuadCollector<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(keyFunction, that.keyFunction) && Objects.equals(valueFunction,
that.valueFunction) && Objects.equals(mapSupplier, that.mapSupplier)
&& Objects.equals(
mergeFunction, that.mergeFunction);
}
@Override
public int hashCode() {
return Objects.hash(keyFunction, valueFunction, mapSupplier, mergeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/quad/ToSortedSetComparatorQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.quad;
import java.util.Comparator;
import java.util.Objects;
import java.util.SortedSet;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.collector.SortedSetUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToSortedSetComparatorQuadCollector<A, B, C, D, Mapped_>
extends UndoableActionableQuadCollector<A, B, C, D, Mapped_, SortedSet<Mapped_>, SortedSetUndoableActionable<Mapped_>> {
private final Comparator<? super Mapped_> comparator;
ToSortedSetComparatorQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper,
Comparator<? super Mapped_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public @NonNull Supplier<SortedSetUndoableActionable<Mapped_>> supplier() {
return () -> SortedSetUndoableActionable.orderBy(comparator);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
ToSortedSetComparatorQuadCollector<?, ?, ?, ?, ?> that = (ToSortedSetComparatorQuadCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(comparator, that.comparator);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), comparator);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/quad/UndoableActionableQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.quad;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.UndoableActionable;
import org.jspecify.annotations.NonNull;
abstract sealed class UndoableActionableQuadCollector<A, B, C, D, Input_, Output_, Calculator_ extends UndoableActionable<Input_, Output_>>
implements QuadConstraintCollector<A, B, C, D, Calculator_, Output_>
permits MaxComparableQuadCollector, MaxComparatorQuadCollector, MaxPropertyQuadCollector, MinComparableQuadCollector,
MinComparatorQuadCollector, MinPropertyQuadCollector, ToCollectionQuadCollector, ToListQuadCollector,
ToMultiMapQuadCollector, ToSetQuadCollector, ToSimpleMapQuadCollector, ToSortedSetComparatorQuadCollector {
private final QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Input_> mapper;
public UndoableActionableQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Input_> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull PentaFunction<Calculator_, A, B, C, D, Runnable> accumulator() {
return (calculator, a, b, c, d) -> {
final Input_ mapped = mapper.apply(a, b, c, d);
return calculator.insert(mapped);
};
}
@Override
public @NonNull Function<Calculator_, Output_> finisher() {
return UndoableActionable::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (UndoableActionableQuadCollector<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/AndThenTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import org.jspecify.annotations.NonNull;
final class AndThenTriCollector<A, B, C, ResultContainer_, Intermediate_, Result_>
implements TriConstraintCollector<A, B, C, ResultContainer_, Result_> {
private final TriConstraintCollector<A, B, C, ResultContainer_, Intermediate_> delegate;
private final Function<Intermediate_, Result_> mappingFunction;
AndThenTriCollector(TriConstraintCollector<A, B, C, ResultContainer_, Intermediate_> delegate,
Function<Intermediate_, Result_> mappingFunction) {
this.delegate = Objects.requireNonNull(delegate);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
public @NonNull Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public @NonNull QuadFunction<ResultContainer_, A, B, C, Runnable> accumulator() {
return delegate.accumulator();
}
@Override
public @NonNull Function<ResultContainer_, Result_> finisher() {
var finisher = delegate.finisher();
return container -> mappingFunction.apply(finisher.apply(container));
}
@Override
public boolean equals(Object o) {
if (o instanceof AndThenTriCollector<?, ?, ?, ?, ?, ?> other) {
return Objects.equals(delegate, other.delegate)
&& Objects.equals(mappingFunction, other.mappingFunction);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(delegate, mappingFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/AverageIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.IntAverageCalculator;
import org.jspecify.annotations.NonNull;
final class AverageIntTriCollector<A, B, C> extends IntCalculatorTriCollector<A, B, C, Double, IntAverageCalculator> {
AverageIntTriCollector(ToIntTriFunction<? super A, ? super B, ? super C> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<IntAverageCalculator> supplier() {
return IntAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/AverageLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.LongAverageCalculator;
import org.jspecify.annotations.NonNull;
final class AverageLongTriCollector<A, B, C> extends LongCalculatorTriCollector<A, B, C, Double, LongAverageCalculator> {
AverageLongTriCollector(ToLongTriFunction<? super A, ? super B, ? super C> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<LongAverageCalculator> supplier() {
return LongAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/AverageReferenceTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.ReferenceAverageCalculator;
import org.jspecify.annotations.NonNull;
final class AverageReferenceTriCollector<A, B, C, Mapped_, Average_>
extends
ObjectCalculatorTriCollector<A, B, C, Mapped_, Average_, Mapped_, ReferenceAverageCalculator<Mapped_, Average_>> {
private final Supplier<ReferenceAverageCalculator<Mapped_, Average_>> calculatorSupplier;
AverageReferenceTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper,
Supplier<ReferenceAverageCalculator<Mapped_, Average_>> calculatorSupplier) {
super(mapper);
this.calculatorSupplier = calculatorSupplier;
}
@Override
public @NonNull Supplier<ReferenceAverageCalculator<Mapped_, Average_>> supplier() {
return calculatorSupplier;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
AverageReferenceTriCollector<?, ?, ?, ?, ?> that = (AverageReferenceTriCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(calculatorSupplier, that.calculatorSupplier);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), calculatorSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ComposeFourTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.util.Quadruple;
import org.jspecify.annotations.NonNull;
final class ComposeFourTriCollector<A, B, C, ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_, Result1_, Result2_, Result3_, Result4_, Result_>
implements
TriConstraintCollector<A, B, C, Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>, Result_> {
private final TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first;
private final TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second;
private final TriConstraintCollector<A, B, C, ResultHolder3_, Result3_> third;
private final TriConstraintCollector<A, B, C, ResultHolder4_, Result4_> fourth;
private final QuadFunction<Result1_, Result2_, Result3_, Result4_, Result_> composeFunction;
private final Supplier<ResultHolder1_> firstSupplier;
private final Supplier<ResultHolder2_> secondSupplier;
private final Supplier<ResultHolder3_> thirdSupplier;
private final Supplier<ResultHolder4_> fourthSupplier;
private final QuadFunction<ResultHolder1_, A, B, C, Runnable> firstAccumulator;
private final QuadFunction<ResultHolder2_, A, B, C, Runnable> secondAccumulator;
private final QuadFunction<ResultHolder3_, A, B, C, Runnable> thirdAccumulator;
private final QuadFunction<ResultHolder4_, A, B, C, Runnable> fourthAccumulator;
private final Function<ResultHolder1_, Result1_> firstFinisher;
private final Function<ResultHolder2_, Result2_> secondFinisher;
private final Function<ResultHolder3_, Result3_> thirdFinisher;
private final Function<ResultHolder4_, Result4_> fourthFinisher;
ComposeFourTriCollector(TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first,
TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second,
TriConstraintCollector<A, B, C, ResultHolder3_, Result3_> third,
TriConstraintCollector<A, B, C, ResultHolder4_, Result4_> fourth,
QuadFunction<Result1_, Result2_, Result3_, Result4_, Result_> composeFunction) {
this.first = first;
this.second = second;
this.third = third;
this.fourth = fourth;
this.composeFunction = composeFunction;
this.firstSupplier = first.supplier();
this.secondSupplier = second.supplier();
this.thirdSupplier = third.supplier();
this.fourthSupplier = fourth.supplier();
this.firstAccumulator = first.accumulator();
this.secondAccumulator = second.accumulator();
this.thirdAccumulator = third.accumulator();
this.fourthAccumulator = fourth.accumulator();
this.firstFinisher = first.finisher();
this.secondFinisher = second.finisher();
this.thirdFinisher = third.finisher();
this.fourthFinisher = fourth.finisher();
}
@Override
public @NonNull Supplier<Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>> supplier() {
return () -> {
ResultHolder1_ a = firstSupplier.get();
ResultHolder2_ b = secondSupplier.get();
ResultHolder3_ c = thirdSupplier.get();
return new Quadruple<>(a, b, c, fourthSupplier.get());
};
}
@Override
public @NonNull QuadFunction<Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>, A, B, C, Runnable>
accumulator() {
return (resultHolder, a, b, c) -> composeUndo(firstAccumulator.apply(resultHolder.a(), a, b, c),
secondAccumulator.apply(resultHolder.b(), a, b, c),
thirdAccumulator.apply(resultHolder.c(), a, b, c),
fourthAccumulator.apply(resultHolder.d(), a, b, c));
}
private static Runnable composeUndo(Runnable first, Runnable second, Runnable third,
Runnable fourth) {
return () -> {
first.run();
second.run();
third.run();
fourth.run();
};
}
@Override
public @NonNull Function<Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>, Result_> finisher() {
return resultHolder -> composeFunction.apply(firstFinisher.apply(resultHolder.a()),
secondFinisher.apply(resultHolder.b()),
thirdFinisher.apply(resultHolder.c()),
fourthFinisher.apply(resultHolder.d()));
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ComposeFourTriCollector<?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(first, that.first) && Objects.equals(second,
that.second) && Objects.equals(third, that.third)
&& Objects.equals(fourth,
that.fourth)
&& Objects.equals(composeFunction, that.composeFunction);
}
@Override
public int hashCode() {
return Objects.hash(first, second, third, fourth, composeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ComposeThreeTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.util.Triple;
import org.jspecify.annotations.NonNull;
final class ComposeThreeTriCollector<A, B, C, ResultHolder1_, ResultHolder2_, ResultHolder3_, Result1_, Result2_, Result3_, Result_>
implements TriConstraintCollector<A, B, C, Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>, Result_> {
private final TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first;
private final TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second;
private final TriConstraintCollector<A, B, C, ResultHolder3_, Result3_> third;
private final TriFunction<Result1_, Result2_, Result3_, Result_> composeFunction;
private final Supplier<ResultHolder1_> firstSupplier;
private final Supplier<ResultHolder2_> secondSupplier;
private final Supplier<ResultHolder3_> thirdSupplier;
private final QuadFunction<ResultHolder1_, A, B, C, Runnable> firstAccumulator;
private final QuadFunction<ResultHolder2_, A, B, C, Runnable> secondAccumulator;
private final QuadFunction<ResultHolder3_, A, B, C, Runnable> thirdAccumulator;
private final Function<ResultHolder1_, Result1_> firstFinisher;
private final Function<ResultHolder2_, Result2_> secondFinisher;
private final Function<ResultHolder3_, Result3_> thirdFinisher;
ComposeThreeTriCollector(TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first,
TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second,
TriConstraintCollector<A, B, C, ResultHolder3_, Result3_> third,
TriFunction<Result1_, Result2_, Result3_, Result_> composeFunction) {
this.first = first;
this.second = second;
this.third = third;
this.composeFunction = composeFunction;
this.firstSupplier = first.supplier();
this.secondSupplier = second.supplier();
this.thirdSupplier = third.supplier();
this.firstAccumulator = first.accumulator();
this.secondAccumulator = second.accumulator();
this.thirdAccumulator = third.accumulator();
this.firstFinisher = first.finisher();
this.secondFinisher = second.finisher();
this.thirdFinisher = third.finisher();
}
@Override
public @NonNull Supplier<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>> supplier() {
return () -> {
ResultHolder1_ a = firstSupplier.get();
ResultHolder2_ b = secondSupplier.get();
return new Triple<>(a, b, thirdSupplier.get());
};
}
@Override
public @NonNull QuadFunction<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>, A, B, C, Runnable> accumulator() {
return (resultHolder, a, b, c) -> composeUndo(firstAccumulator.apply(resultHolder.a(), a, b, c),
secondAccumulator.apply(resultHolder.b(), a, b, c),
thirdAccumulator.apply(resultHolder.c(), a, b, c));
}
private static Runnable composeUndo(Runnable first, Runnable second, Runnable third) {
return () -> {
first.run();
second.run();
third.run();
};
}
@Override
public @NonNull Function<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>, Result_> finisher() {
return resultHolder -> composeFunction.apply(firstFinisher.apply(resultHolder.a()),
secondFinisher.apply(resultHolder.b()),
thirdFinisher.apply(resultHolder.c()));
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ComposeThreeTriCollector<?, ?, ?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(first, that.first) && Objects.equals(second,
that.second) && Objects.equals(third, that.third)
&& Objects.equals(composeFunction,
that.composeFunction);
}
@Override
public int hashCode() {
return Objects.hash(first, second, third, composeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ComposeTwoTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
final class ComposeTwoTriCollector<A, B, C, ResultHolder1_, ResultHolder2_, Result1_, Result2_, Result_>
implements TriConstraintCollector<A, B, C, Pair<ResultHolder1_, ResultHolder2_>, Result_> {
private final TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first;
private final TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second;
private final BiFunction<Result1_, Result2_, Result_> composeFunction;
private final Supplier<ResultHolder1_> firstSupplier;
private final Supplier<ResultHolder2_> secondSupplier;
private final QuadFunction<ResultHolder1_, A, B, C, Runnable> firstAccumulator;
private final QuadFunction<ResultHolder2_, A, B, C, Runnable> secondAccumulator;
private final Function<ResultHolder1_, Result1_> firstFinisher;
private final Function<ResultHolder2_, Result2_> secondFinisher;
ComposeTwoTriCollector(TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first,
TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second,
BiFunction<Result1_, Result2_, Result_> composeFunction) {
this.first = first;
this.second = second;
this.composeFunction = composeFunction;
this.firstSupplier = first.supplier();
this.secondSupplier = second.supplier();
this.firstAccumulator = first.accumulator();
this.secondAccumulator = second.accumulator();
this.firstFinisher = first.finisher();
this.secondFinisher = second.finisher();
}
@Override
public @NonNull Supplier<Pair<ResultHolder1_, ResultHolder2_>> supplier() {
return () -> new Pair<>(firstSupplier.get(), secondSupplier.get());
}
@Override
public @NonNull QuadFunction<Pair<ResultHolder1_, ResultHolder2_>, A, B, C, Runnable> accumulator() {
return (resultHolder, a, b, c) -> composeUndo(firstAccumulator.apply(resultHolder.key(), a, b, c),
secondAccumulator.apply(resultHolder.value(), a, b, c));
}
private static Runnable composeUndo(Runnable first, Runnable second) {
return () -> {
first.run();
second.run();
};
}
@Override
public @NonNull Function<Pair<ResultHolder1_, ResultHolder2_>, Result_> finisher() {
return resultHolder -> composeFunction.apply(firstFinisher.apply(resultHolder.key()),
secondFinisher.apply(resultHolder.value()));
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ComposeTwoTriCollector<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(first, that.first) && Objects.equals(second,
that.second) && Objects.equals(composeFunction, that.composeFunction);
}
@Override
public int hashCode() {
return Objects.hash(first, second, composeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ConditionalTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NonNull;
final class ConditionalTriCollector<A, B, C, ResultContainer_, Result_>
implements TriConstraintCollector<A, B, C, ResultContainer_, Result_> {
private final TriPredicate<A, B, C> predicate;
private final TriConstraintCollector<A, B, C, ResultContainer_, Result_> delegate;
private final QuadFunction<ResultContainer_, A, B, C, Runnable> innerAccumulator;
ConditionalTriCollector(TriPredicate<A, B, C> predicate,
TriConstraintCollector<A, B, C, ResultContainer_, Result_> delegate) {
this.predicate = predicate;
this.delegate = delegate;
this.innerAccumulator = delegate.accumulator();
}
@Override
public @NonNull Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public @NonNull QuadFunction<ResultContainer_, A, B, C, Runnable> accumulator() {
return (resultContainer, a, b, c) -> {
if (predicate.test(a, b, c)) {
return innerAccumulator.apply(resultContainer, a, b, c);
} else {
return ConstantLambdaUtils.noop();
}
};
}
@Override
public @NonNull Function<ResultContainer_, Result_> finisher() {
return delegate.finisher();
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ConditionalTriCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(predicate, that.predicate) && Objects.equals(delegate, that.delegate);
}
@Override
public int hashCode() {
return Objects.hash(predicate, delegate);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ConnectedRangesTriConstraintCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.common.ConnectedRangeChain;
import ai.timefold.solver.core.impl.score.stream.collector.ConnectedRangesCalculator;
import ai.timefold.solver.core.impl.score.stream.collector.connected_ranges.Range;
import org.jspecify.annotations.NonNull;
final class ConnectedRangesTriConstraintCollector<A, B, C, Interval_, Point_ extends Comparable<Point_>, Difference_ extends Comparable<Difference_>>
extends
ObjectCalculatorTriCollector<A, B, C, Interval_, ConnectedRangeChain<Interval_, Point_, Difference_>, Range<Interval_, Point_>, ConnectedRangesCalculator<Interval_, Point_, Difference_>> {
private final Function<? super Interval_, ? extends Point_> startMap;
private final Function<? super Interval_, ? extends Point_> endMap;
private final BiFunction<? super Point_, ? super Point_, ? extends Difference_> differenceFunction;
public ConnectedRangesTriConstraintCollector(TriFunction<? super A, ? super B, ? super C, ? extends Interval_> mapper,
Function<? super Interval_, ? extends Point_> startMap, Function<? super Interval_, ? extends Point_> endMap,
BiFunction<? super Point_, ? super Point_, ? extends Difference_> differenceFunction) {
super(mapper);
this.startMap = startMap;
this.endMap = endMap;
this.differenceFunction = differenceFunction;
}
@Override
public @NonNull Supplier<ConnectedRangesCalculator<Interval_, Point_, Difference_>> supplier() {
return () -> new ConnectedRangesCalculator<>(startMap, endMap, differenceFunction);
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof ConnectedRangesTriConstraintCollector<?, ?, ?, ?, ?, ?> that))
return false;
if (!super.equals(o))
return false;
return Objects.equals(startMap, that.startMap) && Objects.equals(endMap,
that.endMap) && Objects.equals(differenceFunction, that.differenceFunction);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), startMap, endMap, differenceFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ConsecutiveSequencesTriConstraintCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import ai.timefold.solver.core.impl.score.stream.collector.SequenceCalculator;
import org.jspecify.annotations.NonNull;
final class ConsecutiveSequencesTriConstraintCollector<A, B, C, Result_>
extends
ObjectCalculatorTriCollector<A, B, C, Result_, SequenceChain<Result_, Integer>, Result_, SequenceCalculator<Result_>> {
private final ToIntFunction<Result_> indexMap;
public ConsecutiveSequencesTriConstraintCollector(TriFunction<A, B, C, Result_> resultMap,
ToIntFunction<Result_> indexMap) {
super(resultMap);
this.indexMap = Objects.requireNonNull(indexMap);
}
@Override
public @NonNull Supplier<SequenceCalculator<Result_>> supplier() {
return () -> new SequenceCalculator<>(indexMap);
}
@Override
public boolean equals(Object o) {
if (o instanceof ConsecutiveSequencesTriConstraintCollector<?, ?, ?, ?> other) {
return Objects.equals(mapper, other.mapper)
&& Objects.equals(indexMap, other.indexMap);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(mapper, indexMap);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/CountDistinctIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.IntDistinctCountCalculator;
import org.jspecify.annotations.NonNull;
final class CountDistinctIntTriCollector<A, B, C, Mapped_>
extends ObjectCalculatorTriCollector<A, B, C, Mapped_, Integer, Mapped_, IntDistinctCountCalculator<Mapped_>> {
CountDistinctIntTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<IntDistinctCountCalculator<Mapped_>> supplier() {
return IntDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/CountDistinctLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.LongDistinctCountCalculator;
import org.jspecify.annotations.NonNull;
final class CountDistinctLongTriCollector<A, B, C, Mapped_>
extends ObjectCalculatorTriCollector<A, B, C, Mapped_, Long, Mapped_, LongDistinctCountCalculator<Mapped_>> {
CountDistinctLongTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<LongDistinctCountCalculator<Mapped_>> supplier() {
return LongDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/CountIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.IntCounter;
import org.jspecify.annotations.NonNull;
final class CountIntTriCollector<A, B, C> implements TriConstraintCollector<A, B, C, IntCounter, Integer> {
private final static CountIntTriCollector<?, ?, ?> INSTANCE = new CountIntTriCollector<>();
private CountIntTriCollector() {
}
@SuppressWarnings("unchecked")
static <A, B, C> CountIntTriCollector<A, B, C> getInstance() {
return (CountIntTriCollector<A, B, C>) INSTANCE;
}
@Override
public @NonNull Supplier<IntCounter> supplier() {
return IntCounter::new;
}
@Override
public @NonNull QuadFunction<IntCounter, A, B, C, Runnable> accumulator() {
return (counter, a, b, c) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public @NonNull Function<IntCounter, Integer> finisher() {
return IntCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/CountLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.LongCounter;
import org.jspecify.annotations.NonNull;
final class CountLongTriCollector<A, B, C> implements TriConstraintCollector<A, B, C, LongCounter, Long> {
private final static CountLongTriCollector<?, ?, ?> INSTANCE = new CountLongTriCollector<>();
private CountLongTriCollector() {
}
@SuppressWarnings("unchecked")
static <A, B, C> CountLongTriCollector<A, B, C> getInstance() {
return (CountLongTriCollector<A, B, C>) INSTANCE;
}
@Override
public @NonNull Supplier<LongCounter> supplier() {
return LongCounter::new;
}
@Override
public @NonNull QuadFunction<LongCounter, A, B, C, Runnable> accumulator() {
return (counter, a, b, c) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public @NonNull Function<LongCounter, Long> finisher() {
return LongCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/InnerTriConstraintCollectors.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Duration;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.function.TriPredicate;
import ai.timefold.solver.core.api.score.stream.common.ConnectedRangeChain;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.ReferenceAverageCalculator;
public class InnerTriConstraintCollectors {
public static <A, B, C> TriConstraintCollector<A, B, C, ?, Double> average(
ToIntTriFunction<? super A, ? super B, ? super C> mapper) {
return new AverageIntTriCollector<>(mapper);
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, Double> average(
ToLongTriFunction<? super A, ? super B, ? super C> mapper) {
return new AverageLongTriCollector<>(mapper);
}
static <A, B, C, Mapped_, Average_> TriConstraintCollector<A, B, C, ?, Average_> average(
TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper,
Supplier<ReferenceAverageCalculator<Mapped_, Average_>> calculatorSupplier) {
return new AverageReferenceTriCollector<>(mapper, calculatorSupplier);
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, BigDecimal> averageBigDecimal(
TriFunction<? super A, ? super B, ? super C, ? extends BigDecimal> mapper) {
return average(mapper, ReferenceAverageCalculator.bigDecimal());
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, BigDecimal> averageBigInteger(
TriFunction<? super A, ? super B, ? super C, ? extends BigInteger> mapper) {
return average(mapper, ReferenceAverageCalculator.bigInteger());
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, Duration> averageDuration(
TriFunction<? super A, ? super B, ? super C, ? extends Duration> mapper) {
return average(mapper, ReferenceAverageCalculator.duration());
}
public static <A, B, C, ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_, Result1_, Result2_, Result3_, Result4_, Result_>
TriConstraintCollector<A, B, C, ?, Result_>
compose(
TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first,
TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second,
TriConstraintCollector<A, B, C, ResultHolder3_, Result3_> third,
TriConstraintCollector<A, B, C, ResultHolder4_, Result4_> fourth,
QuadFunction<Result1_, Result2_, Result3_, Result4_, Result_> composeFunction) {
return new ComposeFourTriCollector<>(
first, second, third, fourth, composeFunction);
}
public static <A, B, C, ResultHolder1_, ResultHolder2_, ResultHolder3_, Result1_, Result2_, Result3_, Result_>
TriConstraintCollector<A, B, C, ?, Result_>
compose(
TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first,
TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second,
TriConstraintCollector<A, B, C, ResultHolder3_, Result3_> third,
TriFunction<Result1_, Result2_, Result3_, Result_> composeFunction) {
return new ComposeThreeTriCollector<>(
first, second, third, composeFunction);
}
public static <A, B, C, ResultHolder1_, ResultHolder2_, Result1_, Result2_, Result_>
TriConstraintCollector<A, B, C, ?, Result_> compose(
TriConstraintCollector<A, B, C, ResultHolder1_, Result1_> first,
TriConstraintCollector<A, B, C, ResultHolder2_, Result2_> second,
BiFunction<Result1_, Result2_, Result_> composeFunction) {
return new ComposeTwoTriCollector<>(first, second,
composeFunction);
}
public static <A, B, C, ResultContainer_, Result_> TriConstraintCollector<A, B, C, ResultContainer_, Result_>
conditionally(
TriPredicate<A, B, C> predicate,
TriConstraintCollector<A, B, C, ResultContainer_, Result_> delegate) {
return new ConditionalTriCollector<>(predicate, delegate);
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, Integer> count() {
return CountIntTriCollector.getInstance();
}
public static <A, B, C, Mapped_> TriConstraintCollector<A, B, C, ?, Integer> countDistinct(
TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
return new CountDistinctIntTriCollector<>(mapper);
}
public static <A, B, C, Mapped_> TriConstraintCollector<A, B, C, ?, Long> countDistinctLong(
TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
return new CountDistinctLongTriCollector<>(mapper);
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, Long> countLong() {
return CountLongTriCollector.getInstance();
}
public static <A, B, C, Result_ extends Comparable<? super Result_>> TriConstraintCollector<A, B, C, ?, Result_> max(
TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper) {
return new MaxComparableTriCollector<>(mapper);
}
public static <A, B, C, Result_> TriConstraintCollector<A, B, C, ?, Result_> max(
TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
return new MaxComparatorTriCollector<>(mapper, comparator);
}
public static <A, B, C, Result_, Property_ extends Comparable<? super Property_>>
TriConstraintCollector<A, B, C, ?, Result_> max(
TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
return new MaxPropertyTriCollector<>(mapper, propertyMapper);
}
public static <A, B, C, Result_ extends Comparable<? super Result_>> TriConstraintCollector<A, B, C, ?, Result_> min(
TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper) {
return new MinComparableTriCollector<>(mapper);
}
public static <A, B, C, Result_> TriConstraintCollector<A, B, C, ?, Result_> min(
TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
return new MinComparatorTriCollector<>(mapper, comparator);
}
public static <A, B, C, Result_, Property_ extends Comparable<? super Property_>>
TriConstraintCollector<A, B, C, ?, Result_> min(
TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
return new MinPropertyTriCollector<>(mapper, propertyMapper);
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, Integer> sum(
ToIntTriFunction<? super A, ? super B, ? super C> mapper) {
return new SumIntTriCollector<>(mapper);
}
public static <A, B, C> TriConstraintCollector<A, B, C, ?, Long> sum(
ToLongTriFunction<? super A, ? super B, ? super C> mapper) {
return new SumLongTriCollector<>(mapper);
}
public static <A, B, C, Result_> TriConstraintCollector<A, B, C, ?, Result_> sum(
TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper, Result_ zero,
BinaryOperator<Result_> adder,
BinaryOperator<Result_> subtractor) {
return new SumReferenceTriCollector<>(mapper, zero, adder, subtractor);
}
public static <A, B, C, Mapped_, Result_ extends Collection<Mapped_>>
TriConstraintCollector<A, B, C, ?, Result_> toCollection(
TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper,
IntFunction<Result_> collectionFunction) {
return new ToCollectionTriCollector<>(mapper, collectionFunction);
}
public static <A, B, C, Mapped_> TriConstraintCollector<A, B, C, ?, List<Mapped_>> toList(
TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
return new ToListTriCollector<>(mapper);
}
public static <A, B, C, Key_, Value_, Set_ extends Set<Value_>, Result_ extends Map<Key_, Set_>>
TriConstraintCollector<A, B, C, ?, Result_> toMap(
TriFunction<? super A, ? super B, ? super C, ? extends Key_> keyFunction,
TriFunction<? super A, ? super B, ? super C, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
IntFunction<Set_> setFunction) {
return new ToMultiMapTriCollector<>(keyFunction, valueFunction, mapSupplier,
setFunction);
}
public static <A, B, C, Key_, Value_, Result_ extends Map<Key_, Value_>>
TriConstraintCollector<A, B, C, ?, Result_> toMap(
TriFunction<? super A, ? super B, ? super C, ? extends Key_> keyFunction,
TriFunction<? super A, ? super B, ? super C, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
BinaryOperator<Value_> mergeFunction) {
return new ToSimpleMapTriCollector<>(keyFunction, valueFunction, mapSupplier,
mergeFunction);
}
public static <A, B, C, Mapped_> TriConstraintCollector<A, B, C, ?, Set<Mapped_>> toSet(
TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
return new ToSetTriCollector<>(mapper);
}
public static <A, B, C, Mapped_> TriConstraintCollector<A, B, C, ?, SortedSet<Mapped_>> toSortedSet(
TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper,
Comparator<? super Mapped_> comparator) {
return new ToSortedSetComparatorTriCollector<>(mapper, comparator);
}
public static <A, B, C, Result_> TriConstraintCollector<A, B, C, ?, SequenceChain<Result_, Integer>>
toConsecutiveSequences(TriFunction<A, B, C, Result_> resultMap, ToIntFunction<Result_> indexMap) {
return new ConsecutiveSequencesTriConstraintCollector<>(resultMap, indexMap);
}
public static <A, B, C, Interval_, Point_ extends Comparable<Point_>, Difference_ extends Comparable<Difference_>>
TriConstraintCollector<A, B, C, ?, ConnectedRangeChain<Interval_, Point_, Difference_>>
toConnectedRanges(TriFunction<? super A, ? super B, ? super C, ? extends Interval_> mapper,
Function<? super Interval_, ? extends Point_> startMap,
Function<? super Interval_, ? extends Point_> endMap,
BiFunction<? super Point_, ? super Point_, ? extends Difference_> differenceFunction) {
return new ConnectedRangesTriConstraintCollector<>(mapper, startMap, endMap,
differenceFunction);
}
public static <A, B, C, Intermediate_, Result_> TriConstraintCollector<A, B, C, ?, Result_>
collectAndThen(TriConstraintCollector<A, B, C, ?, Intermediate_> delegate,
Function<Intermediate_, Result_> mappingFunction) {
return new AndThenTriCollector<>(delegate, mappingFunction);
}
public static <A, B, C, Balanced_> TriConstraintCollector<A, B, C, ?, LoadBalance<Balanced_>> loadBalance(
TriFunction<A, B, C, Balanced_> balancedItemFunction, ToLongTriFunction<A, B, C> loadFunction,
ToLongTriFunction<A, B, C> initialLoadFunction) {
return new LoadBalanceTriCollector<>(balancedItemFunction, loadFunction, initialLoadFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/IntCalculatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.IntCalculator;
import org.jspecify.annotations.NonNull;
abstract sealed class IntCalculatorTriCollector<A, B, C, Output_, Calculator_ extends IntCalculator<Output_>>
implements TriConstraintCollector<A, B, C, Calculator_, Output_> permits AverageIntTriCollector, SumIntTriCollector {
private final ToIntTriFunction<? super A, ? super B, ? super C> mapper;
public IntCalculatorTriCollector(ToIntTriFunction<? super A, ? super B, ? super C> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull QuadFunction<Calculator_, A, B, C, Runnable> accumulator() {
return (calculator, a, b, c) -> {
final int mapped = mapper.applyAsInt(a, b, c);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public @NonNull Function<Calculator_, Output_> finisher() {
return IntCalculator::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (IntCalculatorTriCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/LoadBalanceTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.LoadBalanceImpl;
import org.jspecify.annotations.NonNull;
final class LoadBalanceTriCollector<A, B, C, Balanced_>
implements TriConstraintCollector<A, B, C, LoadBalanceImpl<Balanced_>, LoadBalance<Balanced_>> {
private final TriFunction<A, B, C, Balanced_> balancedItemFunction;
private final ToLongTriFunction<A, B, C> loadFunction;
private final ToLongTriFunction<A, B, C> initialLoadFunction;
public LoadBalanceTriCollector(TriFunction<A, B, C, Balanced_> balancedItemFunction,
ToLongTriFunction<A, B, C> loadFunction,
ToLongTriFunction<A, B, C> initialLoadFunction) {
this.balancedItemFunction = balancedItemFunction;
this.loadFunction = loadFunction;
this.initialLoadFunction = initialLoadFunction;
}
@Override
public @NonNull Supplier<LoadBalanceImpl<Balanced_>> supplier() {
return LoadBalanceImpl::new;
}
@Override
public @NonNull QuadFunction<LoadBalanceImpl<Balanced_>, A, B, C, Runnable> accumulator() {
return (balanceStatistics, a, b, c) -> {
var balanced = balancedItemFunction.apply(a, b, c);
var initialLoad = initialLoadFunction.applyAsLong(a, b, c);
var load = loadFunction.applyAsLong(a, b, c);
return balanceStatistics.registerBalanced(balanced, load, initialLoad);
};
}
@Override
public @NonNull Function<LoadBalanceImpl<Balanced_>, LoadBalance<Balanced_>> finisher() {
return balanceStatistics -> balanceStatistics;
}
@Override
public boolean equals(Object o) {
return o instanceof LoadBalanceTriCollector<?, ?, ?, ?> that
&& Objects.equals(balancedItemFunction, that.balancedItemFunction)
&& Objects.equals(loadFunction, that.loadFunction)
&& Objects.equals(initialLoadFunction, that.initialLoadFunction);
}
@Override
public int hashCode() {
return Objects.hash(balancedItemFunction, loadFunction, initialLoadFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/LongCalculatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.LongCalculator;
import org.jspecify.annotations.NonNull;
abstract sealed class LongCalculatorTriCollector<A, B, C, Output_, Calculator_ extends LongCalculator<Output_>>
implements TriConstraintCollector<A, B, C, Calculator_, Output_> permits AverageLongTriCollector, SumLongTriCollector {
private final ToLongTriFunction<? super A, ? super B, ? super C> mapper;
public LongCalculatorTriCollector(ToLongTriFunction<? super A, ? super B, ? super C> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull QuadFunction<Calculator_, A, B, C, Runnable> accumulator() {
return (calculator, a, b, c) -> {
final long mapped = mapper.applyAsLong(a, b, c);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public @NonNull Function<Calculator_, Output_> finisher() {
return LongCalculator::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (LongCalculatorTriCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/MaxComparableTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MaxComparableTriCollector<A, B, C, Result_ extends Comparable<? super Result_>>
extends UndoableActionableTriCollector<A, B, C, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
MaxComparableTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::maxCalculator;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/MaxComparatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MaxComparatorTriCollector<A, B, C, Result_>
extends UndoableActionableTriCollector<A, B, C, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
private final Comparator<? super Result_> comparator;
MaxComparatorTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return () -> MinMaxUndoableActionable.maxCalculator(comparator);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MaxComparatorTriCollector<?, ?, ?, ?> that = (MaxComparatorTriCollector<?, ?, ?, ?>) object;
return Objects.equals(comparator, that.comparator);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), comparator);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/MaxPropertyTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MaxPropertyTriCollector<A, B, C, Result_, Property_ extends Comparable<? super Property_>>
extends UndoableActionableTriCollector<A, B, C, Result_, Result_, MinMaxUndoableActionable<Result_, Property_>> {
private final Function<? super Result_, ? extends Property_> propertyMapper;
MaxPropertyTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
super(mapper);
this.propertyMapper = propertyMapper;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Property_>> supplier() {
return () -> MinMaxUndoableActionable.maxCalculator(propertyMapper);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MaxPropertyTriCollector<?, ?, ?, ?, ?> that = (MaxPropertyTriCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(propertyMapper, that.propertyMapper);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), propertyMapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/MinComparableTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MinComparableTriCollector<A, B, C, Result_ extends Comparable<? super Result_>>
extends UndoableActionableTriCollector<A, B, C, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
MinComparableTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::minCalculator;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/MinComparatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MinComparatorTriCollector<A, B, C, Result_>
extends UndoableActionableTriCollector<A, B, C, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
private final Comparator<? super Result_> comparator;
MinComparatorTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return () -> MinMaxUndoableActionable.minCalculator(comparator);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MinComparatorTriCollector<?, ?, ?, ?> that = (MinComparatorTriCollector<?, ?, ?, ?>) object;
return Objects.equals(comparator, that.comparator);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), comparator);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/MinPropertyTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MinPropertyTriCollector<A, B, C, Result_, Property_ extends Comparable<? super Property_>>
extends UndoableActionableTriCollector<A, B, C, Result_, Result_, MinMaxUndoableActionable<Result_, Property_>> {
private final Function<? super Result_, ? extends Property_> propertyMapper;
MinPropertyTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
super(mapper);
this.propertyMapper = propertyMapper;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Property_>> supplier() {
return () -> MinMaxUndoableActionable.minCalculator(propertyMapper);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MinPropertyTriCollector<?, ?, ?, ?, ?> that = (MinPropertyTriCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(propertyMapper, that.propertyMapper);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), propertyMapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ObjectCalculatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.ObjectCalculator;
import org.jspecify.annotations.NonNull;
abstract sealed class ObjectCalculatorTriCollector<A, B, C, Input_, Output_, Mapped_, Calculator_ extends ObjectCalculator<Input_, Output_, Mapped_>>
implements TriConstraintCollector<A, B, C, Calculator_, Output_>
permits AverageReferenceTriCollector, ConnectedRangesTriConstraintCollector, ConsecutiveSequencesTriConstraintCollector,
CountDistinctIntTriCollector, CountDistinctLongTriCollector, SumReferenceTriCollector {
protected final TriFunction<? super A, ? super B, ? super C, ? extends Input_> mapper;
public ObjectCalculatorTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Input_> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull QuadFunction<Calculator_, A, B, C, Runnable> accumulator() {
return (calculator, a, b, c) -> {
final var mapped = mapper.apply(a, b, c);
final var saved = calculator.insert(mapped);
return () -> calculator.retract(saved);
};
}
@Override
public @NonNull Function<Calculator_, Output_> finisher() {
return ObjectCalculator::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ObjectCalculatorTriCollector<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/SumIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.IntSumCalculator;
import org.jspecify.annotations.NonNull;
final class SumIntTriCollector<A, B, C> extends IntCalculatorTriCollector<A, B, C, Integer, IntSumCalculator> {
SumIntTriCollector(ToIntTriFunction<? super A, ? super B, ? super C> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<IntSumCalculator> supplier() {
return IntSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/SumLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.LongSumCalculator;
import org.jspecify.annotations.NonNull;
final class SumLongTriCollector<A, B, C> extends LongCalculatorTriCollector<A, B, C, Long, LongSumCalculator> {
SumLongTriCollector(ToLongTriFunction<? super A, ? super B, ? super C> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<LongSumCalculator> supplier() {
return LongSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/SumReferenceTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.ReferenceSumCalculator;
import org.jspecify.annotations.NonNull;
final class SumReferenceTriCollector<A, B, C, Result_>
extends ObjectCalculatorTriCollector<A, B, C, Result_, Result_, Result_, ReferenceSumCalculator<Result_>> {
private final Result_ zero;
private final BinaryOperator<Result_> adder;
private final BinaryOperator<Result_> subtractor;
SumReferenceTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Result_> mapper, Result_ zero,
BinaryOperator<Result_> adder,
BinaryOperator<Result_> subtractor) {
super(mapper);
this.zero = zero;
this.adder = adder;
this.subtractor = subtractor;
}
@Override
public @NonNull Supplier<ReferenceSumCalculator<Result_>> supplier() {
return () -> new ReferenceSumCalculator<>(zero, adder, subtractor);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
SumReferenceTriCollector<?, ?, ?, ?> that = (SumReferenceTriCollector<?, ?, ?, ?>) object;
return Objects.equals(zero, that.zero) && Objects.equals(adder, that.adder) && Objects.equals(
subtractor, that.subtractor);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), zero, adder, subtractor);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ToCollectionTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Collection;
import java.util.Objects;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.CustomCollectionUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToCollectionTriCollector<A, B, C, Mapped_, Result_ extends Collection<Mapped_>>
extends
UndoableActionableTriCollector<A, B, C, Mapped_, Result_, CustomCollectionUndoableActionable<Mapped_, Result_>> {
private final IntFunction<Result_> collectionFunction;
ToCollectionTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper,
IntFunction<Result_> collectionFunction) {
super(mapper);
this.collectionFunction = collectionFunction;
}
@Override
public @NonNull Supplier<CustomCollectionUndoableActionable<Mapped_, Result_>> supplier() {
return () -> new CustomCollectionUndoableActionable<>(collectionFunction);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
ToCollectionTriCollector<?, ?, ?, ?, ?> that = (ToCollectionTriCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(collectionFunction, that.collectionFunction);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), collectionFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ToListTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.List;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.ListUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToListTriCollector<A, B, C, Mapped_>
extends UndoableActionableTriCollector<A, B, C, Mapped_, List<Mapped_>, ListUndoableActionable<Mapped_>> {
ToListTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<ListUndoableActionable<Mapped_>> supplier() {
return ListUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ToMultiMapTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
final class ToMultiMapTriCollector<A, B, C, Key_, Value_, Set_ extends Set<Value_>, Result_ extends Map<Key_, Set_>>
extends
UndoableActionableTriCollector<A, B, C, Pair<Key_, Value_>, Result_, MapUndoableActionable<Key_, Value_, Set_, Result_>> {
private final TriFunction<? super A, ? super B, ? super C, ? extends Key_> keyFunction;
private final TriFunction<? super A, ? super B, ? super C, ? extends Value_> valueFunction;
private final Supplier<Result_> mapSupplier;
private final IntFunction<Set_> setFunction;
ToMultiMapTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Key_> keyFunction,
TriFunction<? super A, ? super B, ? super C, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
IntFunction<Set_> setFunction) {
super((a, b, c) -> new Pair<>(keyFunction.apply(a, b, c), valueFunction.apply(a, b, c)));
this.keyFunction = keyFunction;
this.valueFunction = valueFunction;
this.mapSupplier = mapSupplier;
this.setFunction = setFunction;
}
@Override
public @NonNull Supplier<MapUndoableActionable<Key_, Value_, Set_, Result_>> supplier() {
return () -> MapUndoableActionable.multiMap(mapSupplier, setFunction);
}
// Don't call super equals/hashCode; the groupingFunction is calculated from keyFunction
// and valueFunction
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ToMultiMapTriCollector<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(keyFunction, that.keyFunction) && Objects.equals(valueFunction,
that.valueFunction) && Objects.equals(mapSupplier, that.mapSupplier)
&& Objects.equals(
setFunction, that.setFunction);
}
@Override
public int hashCode() {
return Objects.hash(keyFunction, valueFunction, mapSupplier, setFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ToSetTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Set;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.SetUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToSetTriCollector<A, B, C, Mapped_>
extends UndoableActionableTriCollector<A, B, C, Mapped_, Set<Mapped_>, SetUndoableActionable<Mapped_>> {
ToSetTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<SetUndoableActionable<Mapped_>> supplier() {
return SetUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ToSimpleMapTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Map;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
final class ToSimpleMapTriCollector<A, B, C, Key_, Value_, Result_ extends Map<Key_, Value_>>
extends
UndoableActionableTriCollector<A, B, C, Pair<Key_, Value_>, Result_, MapUndoableActionable<Key_, Value_, Value_, Result_>> {
private final TriFunction<? super A, ? super B, ? super C, ? extends Key_> keyFunction;
private final TriFunction<? super A, ? super B, ? super C, ? extends Value_> valueFunction;
private final Supplier<Result_> mapSupplier;
private final BinaryOperator<Value_> mergeFunction;
ToSimpleMapTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Key_> keyFunction,
TriFunction<? super A, ? super B, ? super C, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
BinaryOperator<Value_> mergeFunction) {
super((a, b, c) -> new Pair<>(keyFunction.apply(a, b, c), valueFunction.apply(a, b, c)));
this.keyFunction = keyFunction;
this.valueFunction = valueFunction;
this.mapSupplier = mapSupplier;
this.mergeFunction = mergeFunction;
}
@Override
public @NonNull Supplier<MapUndoableActionable<Key_, Value_, Value_, Result_>> supplier() {
return () -> MapUndoableActionable.mergeMap(mapSupplier, mergeFunction);
}
// Don't call super equals/hashCode; the groupingFunction is calculated from keyFunction
// and valueFunction
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ToSimpleMapTriCollector<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(keyFunction, that.keyFunction) && Objects.equals(valueFunction,
that.valueFunction) && Objects.equals(mapSupplier, that.mapSupplier)
&& Objects.equals(
mergeFunction, that.mergeFunction);
}
@Override
public int hashCode() {
return Objects.hash(keyFunction, valueFunction, mapSupplier, mergeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/ToSortedSetComparatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Comparator;
import java.util.Objects;
import java.util.SortedSet;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.collector.SortedSetUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToSortedSetComparatorTriCollector<A, B, C, Mapped_>
extends UndoableActionableTriCollector<A, B, C, Mapped_, SortedSet<Mapped_>, SortedSetUndoableActionable<Mapped_>> {
private final Comparator<? super Mapped_> comparator;
ToSortedSetComparatorTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper,
Comparator<? super Mapped_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public @NonNull Supplier<SortedSetUndoableActionable<Mapped_>> supplier() {
return () -> SortedSetUndoableActionable.orderBy(comparator);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
ToSortedSetComparatorTriCollector<?, ?, ?, ?> that = (ToSortedSetComparatorTriCollector<?, ?, ?, ?>) object;
return Objects.equals(comparator, that.comparator);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), comparator);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/tri/UndoableActionableTriCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.tri;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.UndoableActionable;
import org.jspecify.annotations.NonNull;
abstract sealed class UndoableActionableTriCollector<A, B, C, Input_, Output_, Calculator_ extends UndoableActionable<Input_, Output_>>
implements TriConstraintCollector<A, B, C, Calculator_, Output_>
permits MaxComparableTriCollector, MaxComparatorTriCollector, MaxPropertyTriCollector, MinComparableTriCollector,
MinComparatorTriCollector, MinPropertyTriCollector, ToCollectionTriCollector, ToListTriCollector,
ToMultiMapTriCollector, ToSetTriCollector, ToSimpleMapTriCollector, ToSortedSetComparatorTriCollector {
private final TriFunction<? super A, ? super B, ? super C, ? extends Input_> mapper;
public UndoableActionableTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Input_> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull QuadFunction<Calculator_, A, B, C, Runnable> accumulator() {
return (calculator, a, b, c) -> {
final Input_ mapped = mapper.apply(a, b, c);
return calculator.insert(mapped);
};
}
@Override
public @NonNull Function<Calculator_, Output_> finisher() {
return UndoableActionable::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (UndoableActionableTriCollector<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/AndThenUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class AndThenUniCollector<A, ResultContainer_, Intermediate_, Result_>
implements UniConstraintCollector<A, ResultContainer_, Result_> {
private final UniConstraintCollector<A, ResultContainer_, Intermediate_> delegate;
private final Function<Intermediate_, Result_> mappingFunction;
AndThenUniCollector(UniConstraintCollector<A, ResultContainer_, Intermediate_> delegate,
Function<Intermediate_, Result_> mappingFunction) {
this.delegate = Objects.requireNonNull(delegate);
this.mappingFunction = Objects.requireNonNull(mappingFunction);
}
@Override
public @NonNull Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public @NonNull BiFunction<ResultContainer_, A, Runnable> accumulator() {
return delegate.accumulator();
}
@Override
public @Nullable Function<ResultContainer_, Result_> finisher() {
var finisher = delegate.finisher();
return container -> mappingFunction.apply(finisher.apply(container));
}
@Override
public boolean equals(Object o) {
if (o instanceof AndThenUniCollector<?, ?, ?, ?> other) {
return Objects.equals(delegate, other.delegate)
&& Objects.equals(mappingFunction, other.mappingFunction);
}
return false;
}
@Override
public int hashCode() {
return Objects.hash(delegate, mappingFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/AverageIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.impl.score.stream.collector.IntAverageCalculator;
import org.jspecify.annotations.NonNull;
final class AverageIntUniCollector<A> extends IntCalculatorUniCollector<A, Double, IntAverageCalculator> {
AverageIntUniCollector(ToIntFunction<? super A> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<IntAverageCalculator> supplier() {
return IntAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/AverageLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Supplier;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.impl.score.stream.collector.LongAverageCalculator;
import org.jspecify.annotations.NonNull;
final class AverageLongUniCollector<A> extends LongCalculatorUniCollector<A, Double, LongAverageCalculator> {
AverageLongUniCollector(ToLongFunction<? super A> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<LongAverageCalculator> supplier() {
return LongAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/AverageReferenceUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.ReferenceAverageCalculator;
import org.jspecify.annotations.NonNull;
final class AverageReferenceUniCollector<A, Mapped_, Average_>
extends ObjectCalculatorUniCollector<A, Mapped_, Average_, Mapped_, ReferenceAverageCalculator<Mapped_, Average_>> {
private final Supplier<ReferenceAverageCalculator<Mapped_, Average_>> calculatorSupplier;
AverageReferenceUniCollector(Function<? super A, ? extends Mapped_> mapper,
Supplier<ReferenceAverageCalculator<Mapped_, Average_>> calculatorSupplier) {
super(mapper);
this.calculatorSupplier = calculatorSupplier;
}
@Override
public @NonNull Supplier<ReferenceAverageCalculator<Mapped_, Average_>> supplier() {
return calculatorSupplier;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
AverageReferenceUniCollector<?, ?, ?> that = (AverageReferenceUniCollector<?, ?, ?>) object;
return Objects.equals(calculatorSupplier, that.calculatorSupplier);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), calculatorSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ComposeFourUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.util.Quadruple;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class ComposeFourUniCollector<A, ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_, Result1_, Result2_, Result3_, Result4_, Result_>
implements
UniConstraintCollector<A, Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>, Result_> {
private final UniConstraintCollector<A, ResultHolder1_, Result1_> first;
private final UniConstraintCollector<A, ResultHolder2_, Result2_> second;
private final UniConstraintCollector<A, ResultHolder3_, Result3_> third;
private final UniConstraintCollector<A, ResultHolder4_, Result4_> fourth;
private final QuadFunction<Result1_, Result2_, Result3_, Result4_, Result_> composeFunction;
private final Supplier<ResultHolder1_> firstSupplier;
private final Supplier<ResultHolder2_> secondSupplier;
private final Supplier<ResultHolder3_> thirdSupplier;
private final Supplier<ResultHolder4_> fourthSupplier;
private final BiFunction<ResultHolder1_, A, Runnable> firstAccumulator;
private final BiFunction<ResultHolder2_, A, Runnable> secondAccumulator;
private final BiFunction<ResultHolder3_, A, Runnable> thirdAccumulator;
private final BiFunction<ResultHolder4_, A, Runnable> fourthAccumulator;
private final Function<ResultHolder1_, Result1_> firstFinisher;
private final Function<ResultHolder2_, Result2_> secondFinisher;
private final Function<ResultHolder3_, Result3_> thirdFinisher;
private final Function<ResultHolder4_, Result4_> fourthFinisher;
ComposeFourUniCollector(UniConstraintCollector<A, ResultHolder1_, Result1_> first,
UniConstraintCollector<A, ResultHolder2_, Result2_> second,
UniConstraintCollector<A, ResultHolder3_, Result3_> third,
UniConstraintCollector<A, ResultHolder4_, Result4_> fourth,
QuadFunction<Result1_, Result2_, Result3_, Result4_, Result_> composeFunction) {
this.first = first;
this.second = second;
this.third = third;
this.fourth = fourth;
this.composeFunction = composeFunction;
this.firstSupplier = first.supplier();
this.secondSupplier = second.supplier();
this.thirdSupplier = third.supplier();
this.fourthSupplier = fourth.supplier();
this.firstAccumulator = first.accumulator();
this.secondAccumulator = second.accumulator();
this.thirdAccumulator = third.accumulator();
this.fourthAccumulator = fourth.accumulator();
this.firstFinisher = first.finisher();
this.secondFinisher = second.finisher();
this.thirdFinisher = third.finisher();
this.fourthFinisher = fourth.finisher();
}
@Override
public @NonNull Supplier<Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>> supplier() {
return () -> {
ResultHolder1_ a = firstSupplier.get();
ResultHolder2_ b = secondSupplier.get();
ResultHolder3_ c = thirdSupplier.get();
return new Quadruple<>(a, b, c, fourthSupplier.get());
};
}
@Override
public @NonNull BiFunction<Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>, A, Runnable>
accumulator() {
return (resultHolder, a) -> composeUndo(firstAccumulator.apply(resultHolder.a(), a),
secondAccumulator.apply(resultHolder.b(), a),
thirdAccumulator.apply(resultHolder.c(), a),
fourthAccumulator.apply(resultHolder.d(), a));
}
private static Runnable composeUndo(Runnable first, Runnable second, Runnable third,
Runnable fourth) {
return () -> {
first.run();
second.run();
third.run();
fourth.run();
};
}
@Override
public @Nullable Function<Quadruple<ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_>, Result_> finisher() {
return resultHolder -> composeFunction.apply(firstFinisher.apply(resultHolder.a()),
secondFinisher.apply(resultHolder.b()),
thirdFinisher.apply(resultHolder.c()),
fourthFinisher.apply(resultHolder.d()));
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ComposeFourUniCollector<?, ?, ?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(first, that.first) && Objects.equals(second,
that.second) && Objects.equals(third, that.third)
&& Objects.equals(fourth,
that.fourth)
&& Objects.equals(composeFunction, that.composeFunction);
}
@Override
public int hashCode() {
return Objects.hash(first, second, third, fourth, composeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ComposeThreeUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.util.Triple;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class ComposeThreeUniCollector<A, ResultHolder1_, ResultHolder2_, ResultHolder3_, Result1_, Result2_, Result3_, Result_>
implements UniConstraintCollector<A, Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>, Result_> {
private final UniConstraintCollector<A, ResultHolder1_, Result1_> first;
private final UniConstraintCollector<A, ResultHolder2_, Result2_> second;
private final UniConstraintCollector<A, ResultHolder3_, Result3_> third;
private final TriFunction<Result1_, Result2_, Result3_, Result_> composeFunction;
private final Supplier<ResultHolder1_> firstSupplier;
private final Supplier<ResultHolder2_> secondSupplier;
private final Supplier<ResultHolder3_> thirdSupplier;
private final BiFunction<ResultHolder1_, A, Runnable> firstAccumulator;
private final BiFunction<ResultHolder2_, A, Runnable> secondAccumulator;
private final BiFunction<ResultHolder3_, A, Runnable> thirdAccumulator;
private final Function<ResultHolder1_, Result1_> firstFinisher;
private final Function<ResultHolder2_, Result2_> secondFinisher;
private final Function<ResultHolder3_, Result3_> thirdFinisher;
ComposeThreeUniCollector(UniConstraintCollector<A, ResultHolder1_, Result1_> first,
UniConstraintCollector<A, ResultHolder2_, Result2_> second,
UniConstraintCollector<A, ResultHolder3_, Result3_> third,
TriFunction<Result1_, Result2_, Result3_, Result_> composeFunction) {
this.first = first;
this.second = second;
this.third = third;
this.composeFunction = composeFunction;
this.firstSupplier = first.supplier();
this.secondSupplier = second.supplier();
this.thirdSupplier = third.supplier();
this.firstAccumulator = first.accumulator();
this.secondAccumulator = second.accumulator();
this.thirdAccumulator = third.accumulator();
this.firstFinisher = first.finisher();
this.secondFinisher = second.finisher();
this.thirdFinisher = third.finisher();
}
@Override
public @NonNull Supplier<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>> supplier() {
return () -> {
ResultHolder1_ a = firstSupplier.get();
ResultHolder2_ b = secondSupplier.get();
return new Triple<>(a, b, thirdSupplier.get());
};
}
@Override
public @NonNull BiFunction<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>, A, Runnable> accumulator() {
return (resultHolder, a) -> composeUndo(firstAccumulator.apply(resultHolder.a(), a),
secondAccumulator.apply(resultHolder.b(), a),
thirdAccumulator.apply(resultHolder.c(), a));
}
private static Runnable composeUndo(Runnable first, Runnable second, Runnable third) {
return () -> {
first.run();
second.run();
third.run();
};
}
@Override
public @Nullable Function<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>, Result_> finisher() {
return resultHolder -> composeFunction.apply(firstFinisher.apply(resultHolder.a()),
secondFinisher.apply(resultHolder.b()),
thirdFinisher.apply(resultHolder.c()));
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ComposeThreeUniCollector<?, ?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(first, that.first) && Objects.equals(second,
that.second) && Objects.equals(third, that.third)
&& Objects.equals(composeFunction,
that.composeFunction);
}
@Override
public int hashCode() {
return Objects.hash(first, second, third, composeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ComposeTwoUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class ComposeTwoUniCollector<A, ResultHolder1_, ResultHolder2_, Result1_, Result2_, Result_>
implements UniConstraintCollector<A, Pair<ResultHolder1_, ResultHolder2_>, Result_> {
private final UniConstraintCollector<A, ResultHolder1_, Result1_> first;
private final UniConstraintCollector<A, ResultHolder2_, Result2_> second;
private final BiFunction<Result1_, Result2_, Result_> composeFunction;
private final Supplier<ResultHolder1_> firstSupplier;
private final Supplier<ResultHolder2_> secondSupplier;
private final BiFunction<ResultHolder1_, A, Runnable> firstAccumulator;
private final BiFunction<ResultHolder2_, A, Runnable> secondAccumulator;
private final Function<ResultHolder1_, Result1_> firstFinisher;
private final Function<ResultHolder2_, Result2_> secondFinisher;
ComposeTwoUniCollector(UniConstraintCollector<A, ResultHolder1_, Result1_> first,
UniConstraintCollector<A, ResultHolder2_, Result2_> second,
BiFunction<Result1_, Result2_, Result_> composeFunction) {
this.first = first;
this.second = second;
this.composeFunction = composeFunction;
this.firstSupplier = first.supplier();
this.secondSupplier = second.supplier();
this.firstAccumulator = first.accumulator();
this.secondAccumulator = second.accumulator();
this.firstFinisher = first.finisher();
this.secondFinisher = second.finisher();
}
@Override
public @NonNull Supplier<Pair<ResultHolder1_, ResultHolder2_>> supplier() {
return () -> new Pair<>(firstSupplier.get(), secondSupplier.get());
}
@Override
public @NonNull BiFunction<Pair<ResultHolder1_, ResultHolder2_>, A, Runnable> accumulator() {
return (resultHolder, a) -> composeUndo(firstAccumulator.apply(resultHolder.key(), a),
secondAccumulator.apply(resultHolder.value(), a));
}
private static Runnable composeUndo(Runnable first, Runnable second) {
return () -> {
first.run();
second.run();
};
}
@Override
public @Nullable Function<Pair<ResultHolder1_, ResultHolder2_>, Result_> finisher() {
return resultHolder -> composeFunction.apply(firstFinisher.apply(resultHolder.key()),
secondFinisher.apply(resultHolder.value()));
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ComposeTwoUniCollector<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(first, that.first) && Objects.equals(second,
that.second) && Objects.equals(composeFunction, that.composeFunction);
}
@Override
public int hashCode() {
return Objects.hash(first, second, composeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ConditionalUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class ConditionalUniCollector<A, ResultContainer_, Result_>
implements UniConstraintCollector<A, ResultContainer_, Result_> {
private final Predicate<A> predicate;
private final UniConstraintCollector<A, ResultContainer_, Result_> delegate;
private final BiFunction<ResultContainer_, A, Runnable> innerAccumulator;
ConditionalUniCollector(Predicate<A> predicate, UniConstraintCollector<A, ResultContainer_, Result_> delegate) {
this.predicate = predicate;
this.delegate = delegate;
this.innerAccumulator = delegate.accumulator();
}
@Override
public @NonNull Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public @NonNull BiFunction<ResultContainer_, A, Runnable> accumulator() {
return (resultContainer, a) -> {
if (predicate.test(a)) {
return innerAccumulator.apply(resultContainer, a);
} else {
return ConstantLambdaUtils.noop();
}
};
}
@Override
public @Nullable Function<ResultContainer_, Result_> finisher() {
return delegate.finisher();
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ConditionalUniCollector<?, ?, ?>) object;
return Objects.equals(predicate, that.predicate) && Objects.equals(delegate, that.delegate);
}
@Override
public int hashCode() {
return Objects.hash(predicate, delegate);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ConnectedRangesUniConstraintCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.score.stream.common.ConnectedRangeChain;
import ai.timefold.solver.core.impl.score.stream.collector.ConnectedRangesCalculator;
import ai.timefold.solver.core.impl.score.stream.collector.connected_ranges.Range;
import org.jspecify.annotations.NonNull;
final class ConnectedRangesUniConstraintCollector<A, Interval_, Point_ extends Comparable<Point_>, Difference_ extends Comparable<Difference_>>
extends
ObjectCalculatorUniCollector<A, Interval_, ConnectedRangeChain<Interval_, Point_, Difference_>, Range<Interval_, Point_>, ConnectedRangesCalculator<Interval_, Point_, Difference_>> {
private final Function<? super Interval_, ? extends Point_> startMap;
private final Function<? super Interval_, ? extends Point_> endMap;
private final BiFunction<? super Point_, ? super Point_, ? extends Difference_> differenceFunction;
public ConnectedRangesUniConstraintCollector(Function<? super A, ? extends Interval_> mapper,
Function<? super Interval_, ? extends Point_> startMap, Function<? super Interval_, ? extends Point_> endMap,
BiFunction<? super Point_, ? super Point_, ? extends Difference_> differenceFunction) {
super(mapper);
this.startMap = startMap;
this.endMap = endMap;
this.differenceFunction = differenceFunction;
}
@Override
public @NonNull Supplier<ConnectedRangesCalculator<Interval_, Point_, Difference_>> supplier() {
return () -> new ConnectedRangesCalculator<>(startMap, endMap, differenceFunction);
}
@Override
public boolean equals(Object o) {
if (this == o)
return true;
if (!(o instanceof ConnectedRangesUniConstraintCollector<?, ?, ?, ?> that))
return false;
if (!super.equals(o))
return false;
return Objects.equals(startMap, that.startMap) && Objects.equals(endMap,
that.endMap) && Objects.equals(differenceFunction, that.differenceFunction);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), startMap, endMap, differenceFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ConsecutiveSequencesUniConstraintCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import ai.timefold.solver.core.impl.score.stream.collector.SequenceCalculator;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NonNull;
final class ConsecutiveSequencesUniConstraintCollector<A>
extends ObjectCalculatorUniCollector<A, A, SequenceChain<A, Integer>, A, SequenceCalculator<A>> {
private final ToIntFunction<A> indexMap;
public ConsecutiveSequencesUniConstraintCollector(ToIntFunction<A> indexMap) {
super(ConstantLambdaUtils.identity());
this.indexMap = Objects.requireNonNull(indexMap);
}
@Override
public @NonNull Supplier<SequenceCalculator<A>> supplier() {
return () -> new SequenceCalculator<>(indexMap);
}
@Override
public boolean equals(Object o) {
if (o instanceof ConsecutiveSequencesUniConstraintCollector<?> other) {
return Objects.equals(indexMap, other.indexMap);
}
return false;
}
@Override
public int hashCode() {
return indexMap.hashCode();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/CountDistinctIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.IntDistinctCountCalculator;
import org.jspecify.annotations.NonNull;
final class CountDistinctIntUniCollector<A, Mapped_>
extends ObjectCalculatorUniCollector<A, Mapped_, Integer, Mapped_, IntDistinctCountCalculator<Mapped_>> {
CountDistinctIntUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<IntDistinctCountCalculator<Mapped_>> supplier() {
return IntDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/CountDistinctLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.LongDistinctCountCalculator;
import org.jspecify.annotations.NonNull;
final class CountDistinctLongUniCollector<A, Mapped_>
extends ObjectCalculatorUniCollector<A, Mapped_, Long, Mapped_, LongDistinctCountCalculator<Mapped_>> {
CountDistinctLongUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<LongDistinctCountCalculator<Mapped_>> supplier() {
return LongDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/CountIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.IntCounter;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class CountIntUniCollector<A> implements UniConstraintCollector<A, IntCounter, Integer> {
private final static CountIntUniCollector<?> INSTANCE = new CountIntUniCollector<>();
private CountIntUniCollector() {
}
@SuppressWarnings("unchecked")
static <A> CountIntUniCollector<A> getInstance() {
return (CountIntUniCollector<A>) INSTANCE;
}
@Override
public @NonNull Supplier<IntCounter> supplier() {
return IntCounter::new;
}
@Override
public @NonNull BiFunction<IntCounter, A, Runnable> accumulator() {
return (counter, a) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public @Nullable Function<IntCounter, Integer> finisher() {
return IntCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/CountLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.LongCounter;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class CountLongUniCollector<A> implements UniConstraintCollector<A, LongCounter, Long> {
private final static CountLongUniCollector<?> INSTANCE = new CountLongUniCollector<>();
private CountLongUniCollector() {
}
@SuppressWarnings("unchecked")
static <A> CountLongUniCollector<A> getInstance() {
return (CountLongUniCollector<A>) INSTANCE;
}
@Override
public @NonNull Supplier<LongCounter> supplier() {
return LongCounter::new;
}
@Override
public @NonNull BiFunction<LongCounter, A, Runnable> accumulator() {
return (counter, a) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public @Nullable Function<LongCounter, Long> finisher() {
return LongCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/InnerUniConstraintCollectors.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.math.BigDecimal;
import java.math.BigInteger;
import java.time.Duration;
import java.util.Collection;
import java.util.Comparator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.SortedSet;
import java.util.function.BiFunction;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Predicate;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.common.ConnectedRangeChain;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.ReferenceAverageCalculator;
public class InnerUniConstraintCollectors {
public static <A> UniConstraintCollector<A, ?, Double> average(ToIntFunction<? super A> mapper) {
return new AverageIntUniCollector<>(mapper);
}
public static <A> UniConstraintCollector<A, ?, Double> average(ToLongFunction<? super A> mapper) {
return new AverageLongUniCollector<>(mapper);
}
public static <A> UniConstraintCollector<A, ?, BigDecimal> averageBigDecimal(
Function<? super A, ? extends BigDecimal> mapper) {
return new AverageReferenceUniCollector<>(mapper, ReferenceAverageCalculator.bigDecimal());
}
public static <A> UniConstraintCollector<A, ?, BigDecimal> averageBigInteger(
Function<? super A, ? extends BigInteger> mapper) {
return new AverageReferenceUniCollector<>(mapper, ReferenceAverageCalculator.bigInteger());
}
public static <A> UniConstraintCollector<A, ?, Duration> averageDuration(
Function<? super A, ? extends Duration> mapper) {
return new AverageReferenceUniCollector<>(mapper, ReferenceAverageCalculator.duration());
}
public static <A, ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_, Result1_, Result2_, Result3_, Result4_, Result_>
UniConstraintCollector<A, ?, Result_>
compose(
UniConstraintCollector<A, ResultHolder1_, Result1_> first,
UniConstraintCollector<A, ResultHolder2_, Result2_> second,
UniConstraintCollector<A, ResultHolder3_, Result3_> third,
UniConstraintCollector<A, ResultHolder4_, Result4_> fourth,
QuadFunction<Result1_, Result2_, Result3_, Result4_, Result_> composeFunction) {
return new ComposeFourUniCollector<>(
first, second, third, fourth, composeFunction);
}
public static <A, ResultHolder1_, ResultHolder2_, ResultHolder3_, Result1_, Result2_, Result3_, Result_>
UniConstraintCollector<A, ?, Result_>
compose(
UniConstraintCollector<A, ResultHolder1_, Result1_> first,
UniConstraintCollector<A, ResultHolder2_, Result2_> second,
UniConstraintCollector<A, ResultHolder3_, Result3_> third,
TriFunction<Result1_, Result2_, Result3_, Result_> composeFunction) {
return new ComposeThreeUniCollector<>(
first, second, third, composeFunction);
}
public static <A, ResultHolder1_, ResultHolder2_, Result1_, Result2_, Result_>
UniConstraintCollector<A, ?, Result_> compose(
UniConstraintCollector<A, ResultHolder1_, Result1_> first,
UniConstraintCollector<A, ResultHolder2_, Result2_> second,
BiFunction<Result1_, Result2_, Result_> composeFunction) {
return new ComposeTwoUniCollector<>(first, second,
composeFunction);
}
public static <A, ResultContainer_, Result_> UniConstraintCollector<A, ResultContainer_, Result_> conditionally(
Predicate<A> predicate, UniConstraintCollector<A, ResultContainer_, Result_> delegate) {
return new ConditionalUniCollector<>(predicate, delegate);
}
public static <A> UniConstraintCollector<A, ?, Integer> count() {
return CountIntUniCollector.getInstance();
}
public static <A, Mapped_> UniConstraintCollector<A, ?, Integer> countDistinct(
Function<? super A, ? extends Mapped_> mapper) {
return new CountDistinctIntUniCollector<>(mapper);
}
public static <A, Mapped_> UniConstraintCollector<A, ?, Long> countDistinctLong(
Function<? super A, ? extends Mapped_> mapper) {
return new CountDistinctLongUniCollector<>(mapper);
}
public static <A> UniConstraintCollector<A, ?, Long> countLong() {
return CountLongUniCollector.getInstance();
}
public static <A, Result_ extends Comparable<? super Result_>> UniConstraintCollector<A, ?, Result_> max(
Function<? super A, ? extends Result_> mapper) {
return new MaxComparableUniCollector<>(mapper);
}
public static <A, Result_> UniConstraintCollector<A, ?, Result_> max(Function<? super A, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
return new MaxComparatorUniCollector<>(mapper, comparator);
}
public static <A, Result_, Property_ extends Comparable<? super Property_>> UniConstraintCollector<A, ?, Result_>
max(
Function<? super A, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
return new MaxPropertyUniCollector<>(mapper, propertyMapper);
}
public static <A, Result_ extends Comparable<? super Result_>> UniConstraintCollector<A, ?, Result_> min(
Function<? super A, ? extends Result_> mapper) {
return new MinComparableUniCollector<>(mapper);
}
public static <A, Result_> UniConstraintCollector<A, ?, Result_> min(Function<? super A, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
return new MinComparatorUniCollector<>(mapper, comparator);
}
public static <A, Result_, Property_ extends Comparable<? super Property_>> UniConstraintCollector<A, ?, Result_>
min(
Function<? super A, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
return new MinPropertyUniCollector<>(mapper, propertyMapper);
}
public static <A> UniConstraintCollector<A, ?, Integer> sum(ToIntFunction<? super A> mapper) {
return new SumIntUniCollector<>(mapper);
}
public static <A> UniConstraintCollector<A, ?, Long> sum(ToLongFunction<? super A> mapper) {
return new SumLongUniCollector<>(mapper);
}
public static <A, Result_> UniConstraintCollector<A, ?, Result_> sum(Function<? super A, ? extends Result_> mapper,
Result_ zero, BinaryOperator<Result_> adder,
BinaryOperator<Result_> subtractor) {
return new SumReferenceUniCollector<>(mapper, zero, adder, subtractor);
}
public static <A, Mapped_, Result_ extends Collection<Mapped_>> UniConstraintCollector<A, ?, Result_>
toCollection(
Function<? super A, ? extends Mapped_> mapper,
IntFunction<Result_> collectionFunction) {
return new ToCollectionUniCollector<>(mapper, collectionFunction);
}
public static <A, Mapped_> UniConstraintCollector<A, ?, List<Mapped_>> toList(
Function<? super A, ? extends Mapped_> mapper) {
return new ToListUniCollector<>(mapper);
}
public static <A, Key_, Value_, Set_ extends Set<Value_>, Result_ extends Map<Key_, Set_>>
UniConstraintCollector<A, ?, Result_> toMap(
Function<? super A, ? extends Key_> keyFunction,
Function<? super A, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
IntFunction<Set_> setFunction) {
return new ToMultiMapUniCollector<>(keyFunction, valueFunction, mapSupplier, setFunction);
}
public static <A, Key_, Value_, Result_ extends Map<Key_, Value_>> UniConstraintCollector<A, ?, Result_> toMap(
Function<? super A, ? extends Key_> keyFunction,
Function<? super A, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
BinaryOperator<Value_> mergeFunction) {
return new ToSimpleMapUniCollector<>(keyFunction, valueFunction, mapSupplier, mergeFunction);
}
public static <A, Mapped_> UniConstraintCollector<A, ?, Set<Mapped_>> toSet(Function<? super A, ? extends Mapped_> mapper) {
return new ToSetUniCollector<>(mapper);
}
public static <A, Mapped_> UniConstraintCollector<A, ?, SortedSet<Mapped_>> toSortedSet(
Function<? super A, ? extends Mapped_> mapper,
Comparator<? super Mapped_> comparator) {
return new ToSortedSetComparatorUniCollector<>(mapper, comparator);
}
public static <A> UniConstraintCollector<A, ?, SequenceChain<A, Integer>>
toConsecutiveSequences(ToIntFunction<A> indexMap) {
return new ConsecutiveSequencesUniConstraintCollector<>(indexMap);
}
public static <A, Interval_, Point_ extends Comparable<Point_>, Difference_ extends Comparable<Difference_>>
UniConstraintCollector<A, ?, ConnectedRangeChain<Interval_, Point_, Difference_>>
toConnectedRanges(Function<? super A, ? extends Interval_> mapper,
Function<? super Interval_, ? extends Point_> startMap,
Function<? super Interval_, ? extends Point_> endMap,
BiFunction<? super Point_, ? super Point_, ? extends Difference_> differenceFunction) {
return new ConnectedRangesUniConstraintCollector<>(mapper, startMap, endMap,
differenceFunction);
}
public static <A, Intermediate_, Result_> UniConstraintCollector<A, ?, Result_>
collectAndThen(UniConstraintCollector<A, ?, Intermediate_> delegate,
Function<Intermediate_, Result_> mappingFunction) {
return new AndThenUniCollector<>(delegate, mappingFunction);
}
public static <A, Balanced_> UniConstraintCollector<A, ?, LoadBalance<Balanced_>> loadBalance(
Function<A, Balanced_> balancedItemFunction, ToLongFunction<A> loadFunction,
ToLongFunction<A> initialLoadFunction) {
return new LoadBalanceUniCollector<>(balancedItemFunction, loadFunction, initialLoadFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/IntCalculatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.IntCalculator;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
abstract sealed class IntCalculatorUniCollector<A, Output_, Calculator_ extends IntCalculator<Output_>>
implements UniConstraintCollector<A, Calculator_, Output_> permits AverageIntUniCollector, SumIntUniCollector {
private final ToIntFunction<? super A> mapper;
public IntCalculatorUniCollector(ToIntFunction<? super A> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final int mapped = mapper.applyAsInt(a);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public @Nullable Function<Calculator_, Output_> finisher() {
return IntCalculator::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (IntCalculatorUniCollector<?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/LoadBalanceUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.LoadBalanceImpl;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
final class LoadBalanceUniCollector<A, Balanced_>
implements UniConstraintCollector<A, LoadBalanceImpl<Balanced_>, LoadBalance<Balanced_>> {
private final Function<A, Balanced_> balancedItemFunction;
private final ToLongFunction<A> loadFunction;
private final ToLongFunction<A> initialLoadFunction;
public LoadBalanceUniCollector(Function<A, Balanced_> balancedItemFunction, ToLongFunction<A> loadFunction,
ToLongFunction<A> initialLoadFunction) {
this.balancedItemFunction = balancedItemFunction;
this.loadFunction = loadFunction;
this.initialLoadFunction = initialLoadFunction;
}
@Override
public @NonNull Supplier<LoadBalanceImpl<Balanced_>> supplier() {
return LoadBalanceImpl::new;
}
@Override
public @NonNull BiFunction<LoadBalanceImpl<Balanced_>, A, Runnable> accumulator() {
return (balanceStatistics, a) -> {
var balanced = balancedItemFunction.apply(a);
var initialLoad = initialLoadFunction.applyAsLong(a);
var load = loadFunction.applyAsLong(a);
return balanceStatistics.registerBalanced(balanced, load, initialLoad);
};
}
@Override
public @Nullable Function<LoadBalanceImpl<Balanced_>, LoadBalance<Balanced_>> finisher() {
return balanceStatistics -> balanceStatistics;
}
@Override
public boolean equals(Object o) {
return o instanceof LoadBalanceUniCollector<?, ?> that
&& Objects.equals(balancedItemFunction, that.balancedItemFunction)
&& Objects.equals(loadFunction, that.loadFunction)
&& Objects.equals(initialLoadFunction, that.initialLoadFunction);
}
@Override
public int hashCode() {
return Objects.hash(balancedItemFunction, loadFunction, initialLoadFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/LongCalculatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.collector.LongCalculator;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
abstract sealed class LongCalculatorUniCollector<A, Output_, Calculator_ extends LongCalculator<Output_>>
implements UniConstraintCollector<A, Calculator_, Output_> permits AverageLongUniCollector, SumLongUniCollector {
private final ToLongFunction<? super A> mapper;
public LongCalculatorUniCollector(ToLongFunction<? super A> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final long mapped = mapper.applyAsLong(a);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public @Nullable Function<Calculator_, Output_> finisher() {
return LongCalculator::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (LongCalculatorUniCollector<?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/MaxComparableUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MaxComparableUniCollector<A, Result_ extends Comparable<? super Result_>>
extends UndoableActionableUniCollector<A, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
MaxComparableUniCollector(Function<? super A, ? extends Result_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::maxCalculator;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/MaxComparatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MaxComparatorUniCollector<A, Result_>
extends UndoableActionableUniCollector<A, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
private final Comparator<? super Result_> comparator;
MaxComparatorUniCollector(Function<? super A, ? extends Result_> mapper, Comparator<? super Result_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return () -> MinMaxUndoableActionable.maxCalculator(comparator);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MaxComparatorUniCollector<?, ?> that = (MaxComparatorUniCollector<?, ?>) object;
return Objects.equals(comparator, that.comparator);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), comparator);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/MaxPropertyUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MaxPropertyUniCollector<A, Result_, Property_ extends Comparable<? super Property_>>
extends UndoableActionableUniCollector<A, Result_, Result_, MinMaxUndoableActionable<Result_, Property_>> {
private final Function<? super Result_, ? extends Property_> propertyMapper;
MaxPropertyUniCollector(Function<? super A, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
super(mapper);
this.propertyMapper = propertyMapper;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Property_>> supplier() {
return () -> MinMaxUndoableActionable.maxCalculator(propertyMapper);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MaxPropertyUniCollector<?, ?, ?> that = (MaxPropertyUniCollector<?, ?, ?>) object;
return Objects.equals(propertyMapper, that.propertyMapper);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), propertyMapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/MinComparableUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MinComparableUniCollector<A, Result_ extends Comparable<? super Result_>>
extends UndoableActionableUniCollector<A, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
MinComparableUniCollector(Function<? super A, ? extends Result_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::minCalculator;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/MinComparatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MinComparatorUniCollector<A, Result_>
extends UndoableActionableUniCollector<A, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
private final Comparator<? super Result_> comparator;
MinComparatorUniCollector(Function<? super A, ? extends Result_> mapper, Comparator<? super Result_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return () -> MinMaxUndoableActionable.minCalculator(comparator);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MinComparatorUniCollector<?, ?> that = (MinComparatorUniCollector<?, ?>) object;
return Objects.equals(comparator, that.comparator);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), comparator);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/MinPropertyUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MinMaxUndoableActionable;
import org.jspecify.annotations.NonNull;
final class MinPropertyUniCollector<A, Result_, Property_ extends Comparable<? super Property_>>
extends UndoableActionableUniCollector<A, Result_, Result_, MinMaxUndoableActionable<Result_, Property_>> {
private final Function<? super Result_, ? extends Property_> propertyMapper;
MinPropertyUniCollector(Function<? super A, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
super(mapper);
this.propertyMapper = propertyMapper;
}
@Override
public @NonNull Supplier<MinMaxUndoableActionable<Result_, Property_>> supplier() {
return () -> MinMaxUndoableActionable.minCalculator(propertyMapper);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
MinPropertyUniCollector<?, ?, ?> that = (MinPropertyUniCollector<?, ?, ?>) object;
return Objects.equals(propertyMapper, that.propertyMapper);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), propertyMapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ObjectCalculatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
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.impl.score.stream.collector.ObjectCalculator;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
abstract sealed class ObjectCalculatorUniCollector<A, Input_, Output_, Mapped_, Calculator_ extends ObjectCalculator<Input_, Output_, Mapped_>>
implements UniConstraintCollector<A, Calculator_, Output_>
permits AverageReferenceUniCollector, ConnectedRangesUniConstraintCollector, ConsecutiveSequencesUniConstraintCollector,
CountDistinctIntUniCollector, CountDistinctLongUniCollector, SumReferenceUniCollector {
protected final Function<? super A, ? extends Input_> mapper;
public ObjectCalculatorUniCollector(Function<? super A, ? extends Input_> mapper) {
this.mapper = Objects.requireNonNull(mapper);
}
@Override
public @NonNull BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final var mapped = mapper.apply(a);
final var saved = calculator.insert(mapped);
return () -> calculator.retract(saved);
};
}
@Override
public @Nullable Function<Calculator_, Output_> finisher() {
return ObjectCalculator::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ObjectCalculatorUniCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/SumIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.impl.score.stream.collector.IntSumCalculator;
import org.jspecify.annotations.NonNull;
final class SumIntUniCollector<A> extends IntCalculatorUniCollector<A, Integer, IntSumCalculator> {
SumIntUniCollector(ToIntFunction<? super A> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<IntSumCalculator> supplier() {
return IntSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/SumLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.function.Supplier;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.impl.score.stream.collector.LongSumCalculator;
import org.jspecify.annotations.NonNull;
final class SumLongUniCollector<A> extends LongCalculatorUniCollector<A, Long, LongSumCalculator> {
SumLongUniCollector(ToLongFunction<? super A> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<LongSumCalculator> supplier() {
return LongSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/SumReferenceUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.ReferenceSumCalculator;
import org.jspecify.annotations.NonNull;
final class SumReferenceUniCollector<A, Result_>
extends ObjectCalculatorUniCollector<A, Result_, Result_, Result_, ReferenceSumCalculator<Result_>> {
private final Result_ zero;
private final BinaryOperator<Result_> adder;
private final BinaryOperator<Result_> subtractor;
SumReferenceUniCollector(Function<? super A, ? extends Result_> mapper, Result_ zero, BinaryOperator<Result_> adder,
BinaryOperator<Result_> subtractor) {
super(mapper);
this.zero = zero;
this.adder = adder;
this.subtractor = subtractor;
}
@Override
public @NonNull Supplier<ReferenceSumCalculator<Result_>> supplier() {
return () -> new ReferenceSumCalculator<>(zero, adder, subtractor);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
SumReferenceUniCollector<?, ?> that = (SumReferenceUniCollector<?, ?>) object;
return Objects.equals(zero, that.zero) && Objects.equals(adder, that.adder) && Objects.equals(
subtractor, that.subtractor);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), zero, adder, subtractor);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ToCollectionUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Collection;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.CustomCollectionUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToCollectionUniCollector<A, Mapped_, Result_ extends Collection<Mapped_>>
extends UndoableActionableUniCollector<A, Mapped_, Result_, CustomCollectionUndoableActionable<Mapped_, Result_>> {
private final IntFunction<Result_> collectionFunction;
ToCollectionUniCollector(Function<? super A, ? extends Mapped_> mapper,
IntFunction<Result_> collectionFunction) {
super(mapper);
this.collectionFunction = collectionFunction;
}
@Override
public @NonNull Supplier<CustomCollectionUndoableActionable<Mapped_, Result_>> supplier() {
return () -> new CustomCollectionUndoableActionable<>(collectionFunction);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
ToCollectionUniCollector<?, ?, ?> that = (ToCollectionUniCollector<?, ?, ?>) object;
return Objects.equals(collectionFunction, that.collectionFunction);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), collectionFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ToListUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.ListUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToListUniCollector<A, Mapped_>
extends UndoableActionableUniCollector<A, Mapped_, List<Mapped_>, ListUndoableActionable<Mapped_>> {
ToListUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<ListUndoableActionable<Mapped_>> supplier() {
return ListUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ToMultiMapUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.function.IntFunction;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
final class ToMultiMapUniCollector<A, Key_, Value_, Set_ extends Set<Value_>, Result_ extends Map<Key_, Set_>>
extends
UndoableActionableUniCollector<A, Pair<Key_, Value_>, Result_, MapUndoableActionable<Key_, Value_, Set_, Result_>> {
private final Function<? super A, ? extends Key_> keyFunction;
private final Function<? super A, ? extends Value_> valueFunction;
private final Supplier<Result_> mapSupplier;
private final IntFunction<Set_> setFunction;
ToMultiMapUniCollector(Function<? super A, ? extends Key_> keyFunction,
Function<? super A, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
IntFunction<Set_> setFunction) {
super(a -> new Pair<>(keyFunction.apply(a), valueFunction.apply(a)));
this.keyFunction = keyFunction;
this.valueFunction = valueFunction;
this.mapSupplier = mapSupplier;
this.setFunction = setFunction;
}
@Override
public @NonNull Supplier<MapUndoableActionable<Key_, Value_, Set_, Result_>> supplier() {
return () -> MapUndoableActionable.multiMap(mapSupplier, setFunction);
}
// Don't call super equals/hashCode; the groupingFunction is calculated from keyFunction
// and valueFunction
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ToMultiMapUniCollector<?, ?, ?, ?, ?>) object;
return Objects.equals(keyFunction, that.keyFunction) && Objects.equals(valueFunction,
that.valueFunction) && Objects.equals(mapSupplier, that.mapSupplier)
&& Objects.equals(
setFunction, that.setFunction);
}
@Override
public int hashCode() {
return Objects.hash(keyFunction, valueFunction, mapSupplier, setFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ToSetUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.SetUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToSetUniCollector<A, Mapped_>
extends UndoableActionableUniCollector<A, Mapped_, Set<Mapped_>, SetUndoableActionable<Mapped_>> {
ToSetUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public @NonNull Supplier<SetUndoableActionable<Mapped_>> supplier() {
return SetUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ToSimpleMapUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Map;
import java.util.Objects;
import java.util.function.BinaryOperator;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
import org.jspecify.annotations.NonNull;
final class ToSimpleMapUniCollector<A, Key_, Value_, Result_ extends Map<Key_, Value_>>
extends
UndoableActionableUniCollector<A, Pair<Key_, Value_>, Result_, MapUndoableActionable<Key_, Value_, Value_, Result_>> {
private final Function<? super A, ? extends Key_> keyFunction;
private final Function<? super A, ? extends Value_> valueFunction;
private final Supplier<Result_> mapSupplier;
private final BinaryOperator<Value_> mergeFunction;
ToSimpleMapUniCollector(Function<? super A, ? extends Key_> keyFunction,
Function<? super A, ? extends Value_> valueFunction,
Supplier<Result_> mapSupplier,
BinaryOperator<Value_> mergeFunction) {
super(a -> new Pair<>(keyFunction.apply(a), valueFunction.apply(a)));
this.keyFunction = keyFunction;
this.valueFunction = valueFunction;
this.mapSupplier = mapSupplier;
this.mergeFunction = mergeFunction;
}
@Override
public @NonNull Supplier<MapUndoableActionable<Key_, Value_, Value_, Result_>> supplier() {
return () -> MapUndoableActionable.mergeMap(mapSupplier, mergeFunction);
}
// Don't call super equals/hashCode; the groupingFunction is calculated from keyFunction
// and valueFunction
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (ToSimpleMapUniCollector<?, ?, ?, ?>) object;
return Objects.equals(keyFunction, that.keyFunction) && Objects.equals(valueFunction,
that.valueFunction) && Objects.equals(mapSupplier, that.mapSupplier)
&& Objects.equals(
mergeFunction, that.mergeFunction);
}
@Override
public int hashCode() {
return Objects.hash(keyFunction, valueFunction, mapSupplier, mergeFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/ToSortedSetComparatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Comparator;
import java.util.Objects;
import java.util.SortedSet;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.collector.SortedSetUndoableActionable;
import org.jspecify.annotations.NonNull;
final class ToSortedSetComparatorUniCollector<A, Mapped_>
extends UndoableActionableUniCollector<A, Mapped_, SortedSet<Mapped_>, SortedSetUndoableActionable<Mapped_>> {
private final Comparator<? super Mapped_> comparator;
ToSortedSetComparatorUniCollector(Function<? super A, ? extends Mapped_> mapper,
Comparator<? super Mapped_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public @NonNull Supplier<SortedSetUndoableActionable<Mapped_>> supplier() {
return () -> SortedSetUndoableActionable.orderBy(comparator);
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
if (!super.equals(object))
return false;
ToSortedSetComparatorUniCollector<?, ?> that = (ToSortedSetComparatorUniCollector<?, ?>) object;
return Objects.equals(comparator, that.comparator);
}
@Override
public int hashCode() {
return Objects.hash(super.hashCode(), comparator);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/collector/uni/UndoableActionableUniCollector.java | package ai.timefold.solver.core.impl.score.stream.collector.uni;
import java.util.Objects;
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.impl.score.stream.collector.UndoableActionable;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
abstract sealed class UndoableActionableUniCollector<A, Input_, Output_, Calculator_ extends UndoableActionable<Input_, Output_>>
implements UniConstraintCollector<A, Calculator_, Output_>
permits MaxComparableUniCollector, MaxComparatorUniCollector, MaxPropertyUniCollector, MinComparableUniCollector,
MinComparatorUniCollector, MinPropertyUniCollector, ToCollectionUniCollector, ToListUniCollector,
ToMultiMapUniCollector, ToSetUniCollector, ToSimpleMapUniCollector, ToSortedSetComparatorUniCollector {
private final Function<? super A, ? extends Input_> mapper;
public UndoableActionableUniCollector(Function<? super A, ? extends Input_> mapper) {
this.mapper = mapper;
}
@Override
public @NonNull BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final Input_ mapped = mapper.apply(a);
return calculator.insert(mapped);
};
}
@Override
public @Nullable Function<Calculator_, Output_> finisher() {
return UndoableActionable::result;
}
@Override
public boolean equals(Object object) {
if (this == object)
return true;
if (object == null || getClass() != object.getClass())
return false;
var that = (UndoableActionableUniCollector<?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/AbstractConstraint.java | package ai.timefold.solver.core.impl.score.stream.common;
import java.math.BigDecimal;
import java.util.Objects;
import java.util.regex.Pattern;
import ai.timefold.solver.core.api.domain.constraintweight.ConstraintConfiguration;
import ai.timefold.solver.core.api.score.IBendableScore;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.definition.AbstractBendableScoreDefinition;
import org.jspecify.annotations.NonNull;
public abstract class AbstractConstraint<Solution_, Constraint_ extends AbstractConstraint<Solution_, Constraint_, ConstraintFactory_>, ConstraintFactory_ extends InnerConstraintFactory<Solution_, Constraint_>>
implements Constraint {
private static final String CONSTRAINT_GROUP_REGEX = "^[\\p{L}][\\p{L}\\p{N}\\p{M}_-]*$";
private static final Pattern CONSTRAINT_GROUP_REGEX_PATTERN = Pattern.compile(CONSTRAINT_GROUP_REGEX);
private final ConstraintFactory_ constraintFactory;
private final ConstraintRef constraintRef;
private final String description;
private final String constraintGroup;
private final Score<?> defaultConstraintWeight;
private final ScoreImpactType scoreImpactType;
// Constraint is not generic in uni/bi/..., therefore these can not be typed.
private final Object justificationMapping;
private final Object indictedObjectsMapping;
/**
*
* @param constraintFactory never null
* @param constraintRef never null
* @param description never null
* @param constraintGroup never null
* @param defaultConstraintWeight if null, it means legacy constraint configuration code;
* will require {@link ConstraintConfiguration} to be present.
* @param scoreImpactType never null
* @param justificationMapping never null
* @param indictedObjectsMapping never null
*/
protected AbstractConstraint(ConstraintFactory_ constraintFactory, ConstraintRef constraintRef, String description,
String constraintGroup, Score<?> defaultConstraintWeight, ScoreImpactType scoreImpactType,
Object justificationMapping, Object indictedObjectsMapping) {
this.constraintFactory = Objects.requireNonNull(constraintFactory);
this.constraintRef = Objects.requireNonNull(constraintRef);
this.description = Objects.requireNonNull(description);
this.constraintGroup = Objects.requireNonNull(constraintGroup);
var matcher = CONSTRAINT_GROUP_REGEX_PATTERN.matcher(constraintGroup);
if (!matcher.matches()) {
throw new IllegalArgumentException("""
The constraintGroup (%s) contains invalid characters.
Only alphanumeric characters, "-" and "_" are allowed.
The string must start with an alphabetic character.
""".formatted(constraintGroup));
}
this.defaultConstraintWeight = defaultConstraintWeight;
this.scoreImpactType = Objects.requireNonNull(scoreImpactType);
this.justificationMapping = justificationMapping; // May be omitted in test code.
this.indictedObjectsMapping = indictedObjectsMapping; // May be omitted in test code.
}
@SuppressWarnings("unchecked")
public final <Score_ extends Score<Score_>> Score_ extractConstraintWeight(Solution_ solution) {
return adjustConstraintWeight((Score_) determineConstraintWeight(solution));
}
private <Score_ extends Score<Score_>> Score_ adjustConstraintWeight(Score_ constraintWeight) {
return switch (scoreImpactType) {
case PENALTY -> constraintWeight.negate();
case REWARD, MIXED -> constraintWeight;
};
}
@SuppressWarnings("unchecked")
private <Score_ extends Score<Score_>> Score_ determineConstraintWeight(Solution_ solution) {
var solutionDescriptor = constraintFactory.getSolutionDescriptor();
var hasConstraintWeight = defaultConstraintWeight != null;
var constraintWeightSupplier = solutionDescriptor.<Score_> getConstraintWeightSupplier();
var hasConstraintWeightSupplier = constraintWeightSupplier != null;
if (!hasConstraintWeight) {
// Branch only possible using the deprecated ConstraintConfiguration and penalizeConfigurable(...).
if (solution == null) {
/*
* In constraint verifier API, we allow for testing constraint providers without having a planning solution.
* However, constraint weights may be using ConstraintConfiguration
* and in that case the solution is required to read the weights from.
* For these cases, we set the constraint weight to the softest possible value, just to make sure that the
* constraint is not ignored.
* The actual value is not used in any way.
*/
return (Score_) solutionDescriptor.getScoreDefinition().getOneSoftestScore();
} else if (hasConstraintWeightSupplier) { // Legacy constraint configuration.
return constraintWeightSupplier.getConstraintWeight(constraintRef, solution);
} else {
throw new UnsupportedOperationException("Impossible state: no %s for constraint (%s)."
.formatted(ConstraintConfiguration.class.getSimpleName(), constraintRef));
}
} else { // Overridable constraint weight using ConstraintWeights.
if (hasConstraintWeightSupplier) {
var weight = constraintWeightSupplier.getConstraintWeight(constraintRef, solution);
if (weight != null) {
return weight;
}
}
AbstractConstraint.validateWeight(solutionDescriptor, constraintRef, (Score_) defaultConstraintWeight);
return (Score_) defaultConstraintWeight;
}
}
public final void assertCorrectImpact(int impact) {
if (impact >= 0) {
return;
}
if (scoreImpactType != ScoreImpactType.MIXED) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ constraintRef + "). " +
"Check constraint provider implementation.");
}
}
public final void assertCorrectImpact(long impact) {
if (impact >= 0L) {
return;
}
if (scoreImpactType != ScoreImpactType.MIXED) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ getConstraintRef() + "). " +
"Check constraint provider implementation.");
}
}
public final void assertCorrectImpact(BigDecimal impact) {
if (impact.signum() >= 0) {
return;
}
if (scoreImpactType != ScoreImpactType.MIXED) {
throw new IllegalStateException("Negative match weight (" + impact + ") for constraint ("
+ getConstraintRef() + "). " +
"Check constraint provider implementation.");
}
}
@Override
public final ConstraintFactory_ getConstraintFactory() {
return constraintFactory;
}
@Override
public ConstraintRef getConstraintRef() {
return constraintRef;
}
@Override
public @NonNull String getDescription() {
return description;
}
@Override
public @NonNull String getConstraintGroup() {
return constraintGroup;
}
@Override
public <Score_ extends Score<Score_>> Score_ getConstraintWeight() {
if (defaultConstraintWeight == null) { // Configurable weights (deprecated) have no default.
return null;
}
return adjustConstraintWeight((Score_) defaultConstraintWeight);
}
public final ScoreImpactType getScoreImpactType() {
return scoreImpactType;
}
public <JustificationMapping_> JustificationMapping_ getJustificationMapping() {
// It is the job of the code constructing the constraint to ensure that this cast is correct.
return (JustificationMapping_) justificationMapping;
}
public <IndictedObjectsMapping_> IndictedObjectsMapping_ getIndictedObjectsMapping() {
// It is the job of the code constructing the constraint to ensure that this cast is correct.
return (IndictedObjectsMapping_) indictedObjectsMapping;
}
public static <Solution_, Score_ extends Score<Score_>> void validateWeight(
SolutionDescriptor<Solution_> solutionDescriptor, ConstraintRef constraintRef, Score_ constraintWeight) {
if (constraintWeight == null) {
throw new IllegalArgumentException("""
The constraintWeight (null) for constraint (%s) must not be null.
Maybe check your constraint implementation."""
.formatted(constraintRef));
}
var scoreDescriptor = solutionDescriptor.<Score_> getScoreDescriptor();
if (!constraintWeight.getClass().isAssignableFrom(constraintWeight.getClass())) {
throw new IllegalArgumentException("""
The constraintWeight (%s) of class (%s) for constraint (%s) must be of the scoreClass (%s).
Maybe check your constraint implementation."""
.formatted(constraintWeight, constraintWeight.getClass(), constraintRef,
scoreDescriptor.getScoreDefinition().getScoreClass()));
}
if (!scoreDescriptor.getScoreDefinition().isPositiveOrZero(constraintWeight)) {
throw new IllegalArgumentException("""
The constraintWeight (%s) for constraint (%s) must be positive or zero.
Maybe check your constraint implementation."""
.formatted(constraintWeight, constraintRef));
}
if (constraintWeight instanceof IBendableScore<?> bendableConstraintWeight) {
var bendableScoreDefinition = (AbstractBendableScoreDefinition<?>) scoreDescriptor.getScoreDefinition();
if (bendableConstraintWeight.hardLevelsSize() != bendableScoreDefinition.getHardLevelsSize()
|| bendableConstraintWeight.softLevelsSize() != bendableScoreDefinition.getSoftLevelsSize()) {
throw new IllegalArgumentException(
"""
The bendable constraintWeight (%s) for constraint (%s) has a hardLevelsSize (%d) or a softLevelsSize (%d) \
that doesn't match the score definition's hardLevelsSize (%d) or softLevelsSize (%d).
Maybe check your constraint implementation."""
.formatted(constraintWeight, constraintRef, bendableConstraintWeight.hardLevelsSize(),
bendableConstraintWeight.softLevelsSize(), bendableScoreDefinition.getHardLevelsSize(),
bendableScoreDefinition.getSoftLevelsSize()));
}
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/AbstractConstraintBuilder.java | package ai.timefold.solver.core.impl.score.stream.common;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintBuilder;
import org.jspecify.annotations.NonNull;
@SuppressWarnings("rawtypes")
public abstract class AbstractConstraintBuilder<Score_ extends Score<Score_>> implements ConstraintBuilder {
private final ConstraintConstructor constraintConstructor;
private final ScoreImpactType impactType;
private final Score_ constraintWeight;
protected AbstractConstraintBuilder(ConstraintConstructor constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
this.constraintConstructor = Objects.requireNonNull(constraintConstructor);
this.impactType = Objects.requireNonNull(impactType);
this.constraintWeight = constraintWeight;
}
protected abstract <JustificationMapping_> JustificationMapping_ getJustificationMapping();
protected abstract <IndictedObjectsMapping_> IndictedObjectsMapping_ getIndictedObjectsMapping();
@SuppressWarnings("unchecked")
@Override
public final @NonNull Constraint asConstraintDescribed(@NonNull String constraintName,
@NonNull String constraintDescription, @NonNull String constraintGroup) {
return constraintConstructor.apply(null, constraintName, constraintDescription, constraintGroup, constraintWeight,
impactType, getJustificationMapping(), getIndictedObjectsMapping());
}
@SuppressWarnings("unchecked")
@Override
public final Constraint asConstraint(String constraintPackage, String constraintName) {
return constraintConstructor.apply(constraintPackage, constraintName, "", Constraint.DEFAULT_CONSTRAINT_GROUP,
constraintWeight, impactType, getJustificationMapping(), getIndictedObjectsMapping());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/AbstractConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.common;
import java.util.Objects;
import ai.timefold.solver.core.api.score.stream.ConstraintStream;
import org.jspecify.annotations.NonNull;
public abstract class AbstractConstraintStream<Solution_> implements ConstraintStream {
private final RetrievalSemantics retrievalSemantics;
protected AbstractConstraintStream(RetrievalSemantics retrievalSemantics) {
this.retrievalSemantics = Objects.requireNonNull(retrievalSemantics);
}
public RetrievalSemantics getRetrievalSemantics() {
return retrievalSemantics;
}
// ************************************************************************
// Getters/setters
// ************************************************************************
@Override
public abstract @NonNull InnerConstraintFactory<Solution_, ?> getConstraintFactory();
protected abstract <JustificationMapping_> JustificationMapping_ getDefaultJustificationMapping();
protected abstract <IndictedObjectsMapping_> IndictedObjectsMapping_ getDefaultIndictedObjectsMapping();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/AbstractConstraintStreamScoreDirectorFactory.java | package ai.timefold.solver.core.impl.score.stream.common;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintMetaModel;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.director.AbstractScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.stream.common.inliner.AbstractScoreInliner;
/**
* FP streams implementation of {@link ScoreDirectorFactory}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @param <Score_> the score type to go with the solution
* @see ScoreDirectorFactory
*/
public abstract class AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_ extends Score<Score_>, Factory_ extends AbstractConstraintStreamScoreDirectorFactory<Solution_, Score_, Factory_>>
extends AbstractScoreDirectorFactory<Solution_, Score_, Factory_> {
protected AbstractConstraintStreamScoreDirectorFactory(SolutionDescriptor<Solution_> solutionDescriptor) {
super(solutionDescriptor);
}
/**
* Creates a new score director, inserts facts and calculates score.
*
* @param facts never null
* @return never null
*/
public abstract AbstractScoreInliner<Score_> fireAndForget(Object... facts);
public abstract ConstraintMetaModel getConstraintMetaModel();
@Override
public boolean supportsConstraintMatching() {
return true;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/ConstraintConstructor.java | package ai.timefold.solver.core.impl.score.stream.common;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
@FunctionalInterface
public interface ConstraintConstructor<Score_ extends Score<Score_>, JustificationMapping_, IndictedObjectsMapping_> {
Constraint apply(String constraintPackage, String constraintName, String constraintDescription, String constraintGroup,
Score_ constraintWeight, ScoreImpactType impactType, JustificationMapping_ justificationMapping,
IndictedObjectsMapping_ indictedObjectsMapping);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/ForEachFilteringCriteria.java | package ai.timefold.solver.core.impl.score.stream.common;
import java.util.function.BiFunction;
import java.util.function.Predicate;
import ai.timefold.solver.core.impl.domain.entity.descriptor.EntityDescriptor;
import ai.timefold.solver.core.impl.domain.variable.declarative.ConsistencyTracker;
import org.jspecify.annotations.NullMarked;
import org.jspecify.annotations.Nullable;
@NullMarked
public enum ForEachFilteringCriteria {
ASSIGNED_AND_CONSISTENT((consistencyTracker, entityDescriptor) -> entityDescriptor.getEntityForEachFilter()
.getAssignedAndConsistentPredicate(consistencyTracker)),
CONSISTENT((consistencyTracker, entityDescriptor) -> entityDescriptor.getEntityForEachFilter()
.getConsistentPredicate(consistencyTracker)),
ALL((ignored1, ignored2) -> null);
private final BiFunction<ConsistencyTracker<?>, EntityDescriptor<?>, @Nullable Predicate<Object>> entityDescriptorToPredicateFunction;
ForEachFilteringCriteria(
BiFunction<ConsistencyTracker<?>, EntityDescriptor<?>, Predicate<Object>> entityDescriptorToPredicateFunction) {
this.entityDescriptorToPredicateFunction = entityDescriptorToPredicateFunction;
}
@Nullable
@SuppressWarnings("unchecked")
public <A> Predicate<A> getFilterForEntityDescriptor(ConsistencyTracker<?> consistencyTracker,
EntityDescriptor<?> entityDescriptor) {
return (Predicate<A>) entityDescriptorToPredicateFunction.apply(consistencyTracker, entityDescriptor);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/InnerConstraintFactory.java | package ai.timefold.solver.core.impl.score.stream.common;
import static ai.timefold.solver.core.api.score.stream.Joiners.lessThan;
import static java.util.stream.Collectors.groupingBy;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
import java.util.function.Function;
import java.util.stream.Collectors;
import ai.timefold.solver.core.api.domain.lookup.PlanningId;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.bi.BiJoiner;
import ai.timefold.solver.core.impl.bavet.bi.joiner.BiJoinerComber;
import ai.timefold.solver.core.impl.bavet.bi.joiner.DefaultBiJoiner;
import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.score.stream.common.uni.InnerUniConstraintStream;
import org.jspecify.annotations.NonNull;
public abstract class InnerConstraintFactory<Solution_, Constraint_ extends Constraint> implements ConstraintFactory {
@Override
public <A> @NonNull BiConstraintStream<A, A> forEachUniquePair(@NonNull Class<A> sourceClass,
BiJoiner<A, A> @NonNull... joiners) {
BiJoinerComber<A, A> joinerComber = BiJoinerComber.comb(joiners);
joinerComber.addJoiner(buildLessThanId(sourceClass));
return ((InnerUniConstraintStream<A>) forEach(sourceClass))
.join(forEach(sourceClass), joinerComber);
}
private <A> DefaultBiJoiner<A, A> buildLessThanId(Class<A> sourceClass) {
SolutionDescriptor<Solution_> solutionDescriptor = getSolutionDescriptor();
MemberAccessor planningIdMemberAccessor = solutionDescriptor.getPlanningIdAccessor(sourceClass);
if (planningIdMemberAccessor == null) {
throw new IllegalArgumentException(
"The fromClass (%s) has no member with a @%s annotation, so the pairs cannot be made unique ([A,B] vs [B,A])."
.formatted(sourceClass, PlanningId.class.getSimpleName()));
}
Function<A, Comparable> planningIdGetter = planningIdMemberAccessor.getGetterFunction();
return (DefaultBiJoiner<A, A>) lessThan(planningIdGetter);
}
@Override
public @NonNull <A> BiConstraintStream<A, A> fromUniquePair(@NonNull Class<A> fromClass,
@NonNull BiJoiner<A, A>... joiners) {
BiJoinerComber<A, A> joinerComber = BiJoinerComber.comb(joiners);
joinerComber.addJoiner(buildLessThanId(fromClass));
return ((InnerUniConstraintStream<A>) from(fromClass))
.join(from(fromClass), joinerComber);
}
public <A> void assertValidFromType(Class<A> fromType) {
SolutionDescriptor<Solution_> solutionDescriptor = getSolutionDescriptor();
Set<Class<?>> problemFactOrEntityClassSet = solutionDescriptor.getProblemFactOrEntityClassSet();
/*
* Need to support the following situations:
* 1/ FactType == FromType; querying for the declared type.
* 2/ FromType extends/implements FactType; querying for impl type where declared type is its interface.
* 3/ FromType super FactType; querying for interface where declared type is its implementation.
*/
boolean hasMatchingType = problemFactOrEntityClassSet.stream()
.anyMatch(factType -> fromType.isAssignableFrom(factType) || factType.isAssignableFrom(fromType));
if (!hasMatchingType) {
List<String> canonicalClassNameList = problemFactOrEntityClassSet.stream()
.map(Class::getCanonicalName)
.sorted()
.toList();
throw new IllegalArgumentException("""
Cannot use class (%s) in a constraint stream as it is neither the same as, \
nor a superclass or superinterface of one of planning entities or problem facts.
Ensure that all from(), join(), ifExists() and ifNotExists() building blocks \
only reference classes assignable from planning entities \
or problem facts (%s) annotated on the planning solution (%s)."""
.formatted(fromType.getCanonicalName(), canonicalClassNameList,
solutionDescriptor.getSolutionClass().getCanonicalName()));
}
}
@SuppressWarnings("unchecked")
public List<Constraint_> buildConstraints(ConstraintProvider constraintProvider) {
Constraint[] constraints = Objects.requireNonNull(constraintProvider.defineConstraints(this),
() -> """
The constraintProvider class (%s)'s defineConstraints() must not return null."
Maybe return an empty array instead if there are no constraints."""
.formatted(constraintProvider.getClass()));
if (Arrays.stream(constraints).anyMatch(Objects::isNull)) {
throw new IllegalStateException("""
The constraintProvider class (%s)'s defineConstraints() must not contain an element that is null.
Maybe don't include any null elements in the %s array."""
.formatted(constraintProvider.getClass(), Constraint.class.getSimpleName()));
}
// Fail fast on duplicate constraint IDs.
Map<ConstraintRef, List<Constraint>> constraintsPerIdMap =
Arrays.stream(constraints).collect(groupingBy(Constraint::getConstraintRef));
constraintsPerIdMap.forEach((constraintRef, duplicateConstraintList) -> {
if (duplicateConstraintList.size() > 1) {
throw new IllegalStateException("There are multiple constraints with the same ID (%s)."
.formatted(constraintRef));
}
});
return Arrays.stream(constraints)
.map(c -> (Constraint_) c)
.collect(Collectors.toList());
}
/**
* @return never null
*/
public abstract SolutionDescriptor<Solution_> getSolutionDescriptor();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/RetrievalSemantics.java | package ai.timefold.solver.core.impl.score.stream.common;
import ai.timefold.solver.core.api.domain.variable.PlanningVariable;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
/**
* Determines the behavior of joins and conditional propagation
* based on whether they are coming off of a constraint stream started by
* either {@link ConstraintFactory#from(Class)}
* or {@link ConstraintFactory#forEach(Class)}
* family of methods.
*
* <p>
* For classes which are not planning entities, all of their instances are always retrieved.
* For classes which are planning entities,
* the difference in behavior depends on whether they use planning variables which allow unassigned values.
*
* @see PlanningVariable#allowsUnassigned()
*/
public enum RetrievalSemantics {
/**
* Joins do not include entities with null planning variables,
* unless specifically requested by join(forEachIncludingUnassigned(...)).
* Conditional propagation does not include null planning variables,
* unless specifically requested using a *IncludingUnassigned() method overload.
*
* <p>
* Applies when the stream comes off of a {@link ConstraintFactory#forEach(Class)} family of methods.
*/
STANDARD,
/**
* Joins include entities with null planning variables if these variables allow unassigned values.
* Conditional propagation always includes entities with null planning variables,
* regardless of whether their planning variables allow unassigned values.
*
* <p>
* Applies when the stream comes off of a {@link ConstraintFactory#from(Class)}
* family of methods.
*
* @deprecated this semantics is deprecated and kept around for backward compatibility reasons.
* It will be removed in 2.0, together with the from() family of methods, along with this entire enum.
*/
@Deprecated(forRemoval = true)
LEGACY
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/ScoreImpactType.java | package ai.timefold.solver.core.impl.score.stream.common;
public enum ScoreImpactType {
REWARD,
PENALTY,
MIXED
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/bi/BiConstraintBuilderImpl.java | package ai.timefold.solver.core.impl.score.stream.common.bi;
import java.util.Collection;
import java.util.Objects;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintBuilder;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraintBuilder;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
import org.jspecify.annotations.NonNull;
public final class BiConstraintBuilderImpl<A, B, Score_ extends Score<Score_>>
extends AbstractConstraintBuilder<Score_>
implements BiConstraintBuilder<A, B, Score_> {
private TriFunction<A, B, Score_, ConstraintJustification> justificationMapping;
private BiFunction<A, B, Collection<Object>> indictedObjectsMapping;
public BiConstraintBuilderImpl(BiConstraintConstructor<A, B, Score_> constraintConstructor, ScoreImpactType impactType,
Score_ constraintWeight) {
super(constraintConstructor, impactType, constraintWeight);
}
@Override
protected TriFunction<A, B, Score_, ConstraintJustification> getJustificationMapping() {
return justificationMapping;
}
@Override
public <ConstraintJustification_ extends ConstraintJustification> @NonNull BiConstraintBuilder<A, B, Score_> justifyWith(
@NonNull TriFunction<A, B, Score_, ConstraintJustification_> justificationMapping) {
if (this.justificationMapping != null) {
throw new IllegalStateException("""
Justification mapping already set (%s).
Maybe the constraint calls justifyWith() twice?"""
.formatted(justificationMapping));
}
this.justificationMapping =
(TriFunction<A, B, Score_, ConstraintJustification>) Objects.requireNonNull(justificationMapping);
return this;
}
@Override
protected BiFunction<A, B, Collection<Object>> getIndictedObjectsMapping() {
return indictedObjectsMapping;
}
@Override
public @NonNull BiConstraintBuilder<A, B, Score_>
indictWith(@NonNull BiFunction<A, B, Collection<Object>> indictedObjectsMapping) {
if (this.indictedObjectsMapping != null) {
throw new IllegalStateException("""
Indicted objects' mapping already set (%s).
Maybe the constraint calls indictWith() twice?"""
.formatted(indictedObjectsMapping));
}
this.indictedObjectsMapping = Objects.requireNonNull(indictedObjectsMapping);
return this;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/bi/BiConstraintConstructor.java | package ai.timefold.solver.core.impl.score.stream.common.bi;
import java.util.Collection;
import java.util.function.BiFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.impl.score.stream.common.ConstraintConstructor;
@FunctionalInterface
public interface BiConstraintConstructor<A, B, Score_ extends Score<Score_>>
extends ConstraintConstructor<Score_, TriFunction<A, B, Score_, Object>, BiFunction<A, B, Collection<?>>> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/bi/InnerBiConstraintStream.java | package ai.timefold.solver.core.impl.score.stream.common.bi;
import static ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics.STANDARD;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Collection;
import java.util.function.BiFunction;
import java.util.function.ToIntBiFunction;
import java.util.function.ToLongBiFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintBuilder;
import ai.timefold.solver.core.api.score.stream.bi.BiConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintStream;
import ai.timefold.solver.core.api.score.stream.tri.TriJoiner;
import ai.timefold.solver.core.impl.score.stream.common.RetrievalSemantics;
import ai.timefold.solver.core.impl.score.stream.common.ScoreImpactType;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
import org.jspecify.annotations.NonNull;
public interface InnerBiConstraintStream<A, B> extends BiConstraintStream<A, B> {
static <A, B> TriFunction<A, B, Score<?>, DefaultConstraintJustification> createDefaultJustificationMapping() {
return (a, b, score) -> DefaultConstraintJustification.of(score, a, b);
}
static <A, B> BiFunction<A, B, Collection<?>> createDefaultIndictedObjectsMapping() {
return Arrays::asList;
}
RetrievalSemantics getRetrievalSemantics();
/**
* This method will return true if the constraint stream is guaranteed to only produce distinct tuples.
* See {@link #distinct()} for details.
*
* @return true if the guarantee of distinct tuples is provided
*/
boolean guaranteesDistinct();
@Override
default <C> @NonNull TriConstraintStream<A, B, C> join(@NonNull Class<C> otherClass, TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == STANDARD) {
return join(getConstraintFactory().forEach(otherClass), joiners);
} else {
return join(getConstraintFactory().from(otherClass), joiners);
}
}
@Override
default @NonNull <C> BiConstraintStream<A, B> ifExists(@NonNull Class<C> otherClass,
TriJoiner<A, B, C> @NonNull... joiners) {
if (getRetrievalSemantics() == STANDARD) {
return ifExists(getConstraintFactory().forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifExists(getConstraintFactory().fromUnfiltered(otherClass), joiners);
}
}
@Override
default @NonNull <C> BiConstraintStream<A, B> ifExistsIncludingUnassigned(@NonNull Class<C> otherClass,
@NonNull TriJoiner<A, B, C> @NonNull... joiners) {
if (getRetrievalSemantics() == STANDARD) {
return ifExists(getConstraintFactory().forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifExists(getConstraintFactory().fromUnfiltered(otherClass), joiners);
}
}
@Override
default <C> @NonNull BiConstraintStream<A, B> ifNotExists(@NonNull Class<C> otherClass,
@NonNull TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == STANDARD) {
return ifNotExists(getConstraintFactory().forEach(otherClass), joiners);
} else {
// Calls fromUnfiltered() for backward compatibility only
return ifNotExists(getConstraintFactory().fromUnfiltered(otherClass), joiners);
}
}
@Override
default <C> @NonNull BiConstraintStream<A, B> ifNotExistsIncludingUnassigned(@NonNull Class<C> otherClass,
@NonNull TriJoiner<A, B, C>... joiners) {
if (getRetrievalSemantics() == STANDARD) {
return ifNotExists(getConstraintFactory().forEachIncludingUnassigned(otherClass), joiners);
} else {
return ifNotExists(getConstraintFactory().fromUnfiltered(otherClass), joiners);
}
}
@Override
default @NonNull BiConstraintStream<A, B> distinct() {
if (guaranteesDistinct()) {
return this;
} else {
return groupBy(ConstantLambdaUtils.biPickFirst(),
ConstantLambdaUtils.biPickSecond());
}
}
@Override
default <Score_ extends Score<Score_>> @NonNull BiConstraintBuilder<A, B, Score_> penalize(@NonNull Score_ constraintWeight,
@NonNull ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default @NonNull <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> penalizeLong(
@NonNull Score_ constraintWeight,
@NonNull ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default @NonNull <Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> penalizeBigDecimal(
@NonNull Score_ constraintWeight,
@NonNull BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default BiConstraintBuilder<A, B, ?> penalizeConfigurable(ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default BiConstraintBuilder<A, B, ?> penalizeConfigurableLong(ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default BiConstraintBuilder<A, B, ?> penalizeConfigurableBigDecimal(BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.PENALTY);
}
@Override
default <Score_ extends Score<Score_>> @NonNull BiConstraintBuilder<A, B, Score_> reward(@NonNull Score_ constraintWeight,
@NonNull ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> @NonNull BiConstraintBuilder<A, B, Score_> rewardLong(
@NonNull Score_ constraintWeight,
@NonNull ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> @NonNull BiConstraintBuilder<A, B, Score_> rewardBigDecimal(
@NonNull Score_ constraintWeight,
@NonNull BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default BiConstraintBuilder<A, B, ?> rewardConfigurable(ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default BiConstraintBuilder<A, B, ?> rewardConfigurableLong(ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default BiConstraintBuilder<A, B, ?> rewardConfigurableBigDecimal(BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.REWARD);
}
@Override
default <Score_ extends Score<Score_>> @NonNull BiConstraintBuilder<A, B, Score_> impact(@NonNull Score_ constraintWeight,
@NonNull ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> @NonNull BiConstraintBuilder<A, B, Score_> impactLong(
@NonNull Score_ constraintWeight,
@NonNull ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default <Score_ extends Score<Score_>> @NonNull BiConstraintBuilder<A, B, Score_> impactBigDecimal(
@NonNull Score_ constraintWeight,
@NonNull BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(constraintWeight, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default BiConstraintBuilder<A, B, ?> impactConfigurable(ToIntBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default BiConstraintBuilder<A, B, ?> impactConfigurableLong(ToLongBiFunction<A, B> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
@Override
default BiConstraintBuilder<A, B, ?> impactConfigurableBigDecimal(BiFunction<A, B, BigDecimal> matchWeigher) {
return innerImpact(null, matchWeigher, ScoreImpactType.MIXED);
}
<Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
ToIntBiFunction<A, B> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
ToLongBiFunction<A, B> matchWeigher,
ScoreImpactType scoreImpactType);
<Score_ extends Score<Score_>> BiConstraintBuilder<A, B, Score_> innerImpact(Score_ constraintWeight,
BiFunction<A, B, BigDecimal> matchWeigher,
ScoreImpactType scoreImpactType);
@Override
default @NonNull Constraint penalize(@NonNull String constraintName, @NonNull Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default @NonNull Constraint penalize(@NonNull String constraintPackage, @NonNull String constraintName,
@NonNull Score<?> constraintWeight) {
return penalize((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default @NonNull Constraint penalizeConfigurable(@NonNull String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintName);
}
@Override
default @NonNull Constraint penalizeConfigurable(@NonNull String constraintPackage, @NonNull String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default @NonNull Constraint reward(@NonNull String constraintName, @NonNull Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default @NonNull Constraint reward(@NonNull String constraintPackage, @NonNull String constraintName,
@NonNull Score<?> constraintWeight) {
return reward((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
@Override
default @NonNull Constraint rewardConfigurable(@NonNull String constraintName) {
return rewardConfigurable()
.asConstraint(constraintName);
}
@Override
default @NonNull Constraint rewardConfigurable(@NonNull String constraintPackage, @NonNull String constraintName) {
return penalizeConfigurable()
.asConstraint(constraintPackage, constraintName);
}
@Override
default @NonNull Constraint impact(@NonNull String constraintName, @NonNull Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintName);
}
@Override
default @NonNull Constraint impact(@NonNull String constraintPackage, @NonNull String constraintName,
@NonNull Score<?> constraintWeight) {
return impact((Score) constraintWeight)
.asConstraint(constraintPackage, constraintName);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/AbstractScoreInliner.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.lang.reflect.InvocationTargetException;
import java.util.Collections;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.Set;
import java.util.TreeMap;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatch;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatchTotal;
import ai.timefold.solver.core.api.score.constraint.Indictment;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.score.buildin.BendableBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.BendableLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.BendableScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardMediumSoftBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardMediumSoftLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardMediumSoftScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardSoftBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardSoftLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.HardSoftScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.SimpleBigDecimalScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.SimpleLongScoreDefinition;
import ai.timefold.solver.core.impl.score.buildin.SimpleScoreDefinition;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.constraint.DefaultConstraintMatchTotal;
import ai.timefold.solver.core.impl.score.constraint.DefaultIndictment;
import ai.timefold.solver.core.impl.score.definition.ScoreDefinition;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
import ai.timefold.solver.core.impl.util.CollectionUtils;
import ai.timefold.solver.core.impl.util.ElementAwareList;
/**
* Keeps track of the working score and constraint matches for a single constraint session.
* Every time constraint weights change, a new instance needs to be created.
*
* @param <Score_>
*/
public abstract class AbstractScoreInliner<Score_ extends Score<Score_>> {
@Deprecated(forRemoval = true)
private static final String CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME =
"ai.timefold.solver.score.stream.inliner";
public static <Score_ extends Score<Score_>, ScoreInliner_ extends AbstractScoreInliner<Score_>> ScoreInliner_
buildScoreInliner(ScoreDefinition<Score_> scoreDefinition, Map<Constraint, Score_> constraintWeightMap,
ConstraintMatchPolicy constraintMatchPolicy) {
if (scoreDefinition instanceof SimpleScoreDefinition) {
return (ScoreInliner_) new SimpleScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof SimpleLongScoreDefinition) {
return (ScoreInliner_) new SimpleLongScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof SimpleBigDecimalScoreDefinition) {
return (ScoreInliner_) new SimpleBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof HardSoftScoreDefinition) {
return (ScoreInliner_) new HardSoftScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof HardSoftLongScoreDefinition) {
return (ScoreInliner_) new HardSoftLongScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof HardSoftBigDecimalScoreDefinition) {
return (ScoreInliner_) new HardSoftBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof HardMediumSoftScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof HardMediumSoftLongScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftLongScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof HardMediumSoftBigDecimalScoreDefinition) {
return (ScoreInliner_) new HardMediumSoftBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchPolicy);
} else if (scoreDefinition instanceof BendableScoreDefinition bendableScoreDefinition) {
return (ScoreInliner_) new BendableScoreInliner((Map) constraintWeightMap, constraintMatchPolicy,
bendableScoreDefinition.getHardLevelsSize(), bendableScoreDefinition.getSoftLevelsSize());
} else if (scoreDefinition instanceof BendableLongScoreDefinition bendableScoreDefinition) {
return (ScoreInliner_) new BendableLongScoreInliner((Map) constraintWeightMap, constraintMatchPolicy,
bendableScoreDefinition.getHardLevelsSize(),
bendableScoreDefinition.getSoftLevelsSize());
} else if (scoreDefinition instanceof BendableBigDecimalScoreDefinition bendableScoreDefinition) {
return (ScoreInliner_) new BendableBigDecimalScoreInliner((Map) constraintWeightMap, constraintMatchPolicy,
bendableScoreDefinition.getHardLevelsSize(), bendableScoreDefinition.getSoftLevelsSize());
} else {
var customScoreInlinerClassName = System.getProperty(CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME);
if (customScoreInlinerClassName == null) {
throw new UnsupportedOperationException("Unknown score definition class (" +
scoreDefinition.getClass().getCanonicalName() + ").\n" +
"If you're attempting to use a custom score, " +
"provide your " + AbstractScoreInliner.class.getSimpleName() + " implementation using the '" +
CUSTOM_SCORE_INLINER_CLASS_PROPERTY_NAME + "' system property.\n" +
"Note: support for custom scores will be removed in Timefold 2.0.");
}
try {
var customScoreInlinerClass = Class.forName(customScoreInlinerClassName);
if (!AbstractScoreInliner.class.isAssignableFrom(customScoreInlinerClass)) {
throw new IllegalStateException("Custom score inliner class (" + customScoreInlinerClassName +
") does not extend " + AbstractScoreInliner.class.getCanonicalName() + ".\n" +
"Note: support for custom scores will be removed in Timefold 2.0.");
}
return ((Class<ScoreInliner_>) customScoreInlinerClass).getConstructor()
.newInstance();
} catch (ClassNotFoundException | NoSuchMethodException | InstantiationException | IllegalAccessException
| InvocationTargetException cause) {
throw new IllegalStateException("Custom score inliner class (" + customScoreInlinerClassName +
") can not be instantiated.\n" +
"Maybe add a no-arg public constructor?\n" +
"Note: support for custom scores will be removed in Timefold 2.0.", cause);
}
}
}
protected final ConstraintMatchPolicy constraintMatchPolicy;
protected final Map<Constraint, Score_> constraintWeightMap;
private final Map<Constraint, ElementAwareList<ConstraintMatchCarrier<Score_>>> constraintMatchMap;
private Map<String, ConstraintMatchTotal<Score_>> constraintIdToConstraintMatchTotalMap = null;
private Map<Object, Indictment<Score_>> indictmentMap = null;
protected AbstractScoreInliner(Map<Constraint, Score_> constraintWeightMap, ConstraintMatchPolicy constraintMatchPolicy) {
this.constraintMatchPolicy = constraintMatchPolicy;
constraintWeightMap.forEach(this::validateConstraintWeight);
this.constraintWeightMap = constraintWeightMap;
if (constraintMatchPolicy.isEnabled()) {
this.constraintMatchMap = CollectionUtils.newIdentityHashMap(constraintWeightMap.size());
for (var constraint : constraintWeightMap.keySet()) {
// Ensure that even constraints without matches have their entry.
this.constraintMatchMap.put(constraint, new ElementAwareList<>());
}
} else {
this.constraintMatchMap = Collections.emptyMap();
}
}
private void validateConstraintWeight(Constraint constraint, Score_ constraintWeight) {
if (constraintWeight == null || constraintWeight.isZero()) {
throw new IllegalArgumentException("Impossible state: The constraintWeight (" +
constraintWeight + ") cannot be zero, constraint (" + constraint +
") should have been culled during session creation.");
}
}
public abstract Score_ extractScore();
/**
* Create a new instance of {@link WeightedScoreImpacter} for a particular constraint.
*
* @param constraint never null
* @return never null
*/
public abstract WeightedScoreImpacter<Score_, ?> buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint);
protected final UndoScoreImpacter addConstraintMatch(Constraint constraint, Score_ score,
ConstraintMatchSupplier<Score_> constraintMatchSupplier, UndoScoreImpacter undoScoreImpact) {
var constraintMatchList = getConstraintMatchList(constraint);
/*
* Creating a constraint match is a heavy operation which may yet be undone.
* Defer creation of the constraint match until a later point.
*/
var entry =
constraintMatchList.add(new ConstraintMatchCarrier<>(constraintMatchSupplier, constraint, score));
clearMaps();
return () -> {
undoScoreImpact.run();
entry.remove();
clearMaps();
};
}
private ElementAwareList<ConstraintMatchCarrier<Score_>> getConstraintMatchList(Constraint constraint) {
// Optimization: computeIfAbsent() would have created a lambda on the hot path.
var constraintMatchList = constraintMatchMap.get(constraint);
if (constraintMatchList == null) {
throw new IllegalStateException(
"Impossible state: Unknown constraint (%s)."
.formatted(constraint.getConstraintRef()));
}
return constraintMatchList;
}
private void clearMaps() {
constraintIdToConstraintMatchTotalMap = null;
indictmentMap = null;
}
public ConstraintMatchPolicy getConstraintMatchPolicy() {
return constraintMatchPolicy;
}
public final Map<String, ConstraintMatchTotal<Score_>> getConstraintIdToConstraintMatchTotalMap() {
if (!constraintMatchPolicy.isEnabled()) {
throw new IllegalStateException("Impossible state: Method called while constraint matching is disabled.");
} else if (constraintIdToConstraintMatchTotalMap == null) {
rebuildConstraintMatchTotals();
}
return constraintIdToConstraintMatchTotalMap;
}
private void rebuildConstraintMatchTotals() {
var constraintIdToConstraintMatchTotalMap = new TreeMap<String, ConstraintMatchTotal<Score_>>();
for (var entry : constraintMatchMap.entrySet()) {
var constraint = entry.getKey();
var constraintMatchTotal =
new DefaultConstraintMatchTotal<>(constraint.getConstraintRef(), constraintWeightMap.get(constraint));
for (var carrier : entry.getValue()) {
// Constraint match instances are only created here when we actually need them.
var constraintMatch = carrier.get();
constraintMatchTotal.addConstraintMatch(constraintMatch);
}
constraintIdToConstraintMatchTotalMap.put(constraint.getConstraintRef().constraintId(), constraintMatchTotal);
}
this.constraintIdToConstraintMatchTotalMap = constraintIdToConstraintMatchTotalMap;
}
public final Map<Object, Indictment<Score_>> getIndictmentMap() {
if (!constraintMatchPolicy.isJustificationEnabled()) {
throw new IllegalStateException("Impossible state: Method called while justifications are disabled.");
} else if (indictmentMap == null) {
rebuildIndictments();
}
return indictmentMap;
}
private void rebuildIndictments() {
var workingIndictmentMap = new LinkedHashMap<Object, Indictment<Score_>>();
for (var entry : constraintMatchMap.entrySet()) {
for (var carrier : entry.getValue()) {
// Constraint match instances are only created here when we actually need them.
var constraintMatch = carrier.get();
for (var indictedObject : constraintMatch.getIndictedObjectList()) {
if (indictedObject == null) { // Users may have sent null, or it came from the default mapping.
continue;
}
var indictment =
(DefaultIndictment<Score_>) getIndictment(workingIndictmentMap, constraintMatch, indictedObject);
/*
* Optimization: In order to not have to go over the indicted object list and remove duplicates,
* we use a method that will silently skip duplicate constraint matches.
* This is harmless because the two identical indicted objects come from the same constraint match.
*/
indictment.addConstraintMatchWithoutFail(constraintMatch);
}
}
}
indictmentMap = workingIndictmentMap;
}
private DefaultIndictment<Score_> getIndictment(Map<Object, Indictment<Score_>> indictmentMap,
ConstraintMatch<Score_> constraintMatch, Object indictedObject) {
// Like computeIfAbsent(), but doesn't create a capturing lambda on the hot path.
var indictment = (DefaultIndictment<Score_>) indictmentMap.get(indictedObject);
if (indictment == null) {
indictment = new DefaultIndictment<>(indictedObject, constraintMatch.getScore().zero());
indictmentMap.put(indictedObject, indictment);
}
return indictment;
}
public Set<Constraint> getConstraints() {
return constraintWeightMap.keySet();
}
private static final class ConstraintMatchCarrier<Score_ extends Score<Score_>>
implements
Supplier<ConstraintMatch<Score_>> {
private final Constraint constraint;
private final ConstraintMatchSupplier<Score_> constraintMatchSupplier;
private final Score_ score;
private ConstraintMatch<Score_> constraintMatch;
private ConstraintMatchCarrier(ConstraintMatchSupplier<Score_> constraintMatchSupplier, Constraint constraint,
Score_ score) {
this.constraint = constraint;
this.constraintMatchSupplier = constraintMatchSupplier;
this.score = score;
}
@Override
public ConstraintMatch<Score_> get() {
if (constraintMatch == null) {
// Repeated requests for score explanation should not create the same constraint match over and over.
constraintMatch = constraintMatchSupplier.apply(constraint, score);
}
return constraintMatch;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/BendableBigDecimalScoreContext.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class BendableBigDecimalScoreContext extends ScoreContext<BendableBigDecimalScore, BendableBigDecimalScoreInliner> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final BigDecimal scoreLevelWeight;
public BendableBigDecimalScoreContext(BendableBigDecimalScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableBigDecimalScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
BigDecimal scoreLevelWeight) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
}
public BendableBigDecimalScoreContext(BendableBigDecimalScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableBigDecimalScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, BigDecimal.ZERO);
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<BendableBigDecimalScore> constraintMatchSupplier) {
BigDecimal softImpact = scoreLevelWeight.multiply(matchWeight);
parent.softScores[scoreLevel] = parent.softScores[scoreLevel].add(softImpact);
UndoScoreImpacter undoScoreImpact =
() -> parent.softScores[scoreLevel] = parent.softScores[scoreLevel].subtract(softImpact);
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableBigDecimalScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<BendableBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = scoreLevelWeight.multiply(matchWeight);
parent.hardScores[scoreLevel] = parent.hardScores[scoreLevel].add(hardImpact);
UndoScoreImpacter undoScoreImpact =
() -> parent.hardScores[scoreLevel] = parent.hardScores[scoreLevel].subtract(hardImpact);
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableBigDecimalScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<BendableBigDecimalScore> constraintMatchSupplier) {
BigDecimal[] hardImpacts = new BigDecimal[hardScoreLevelCount];
BigDecimal[] softImpacts = new BigDecimal[softScoreLevelCount];
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
BigDecimal hardImpact = constraintWeight.hardScore(hardScoreLevel).multiply(matchWeight);
hardImpacts[hardScoreLevel] = hardImpact;
parent.hardScores[hardScoreLevel] = parent.hardScores[hardScoreLevel].add(hardImpact);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
BigDecimal softImpact = constraintWeight.softScore(softScoreLevel).multiply(matchWeight);
softImpacts[softScoreLevel] = softImpact;
parent.softScores[softScoreLevel] = parent.softScores[softScoreLevel].add(softImpact);
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
parent.hardScores[hardScoreLevel] = parent.hardScores[hardScoreLevel].subtract(hardImpacts[hardScoreLevel]);
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
parent.softScores[softScoreLevel] = parent.softScores[softScoreLevel].subtract(softImpacts[softScoreLevel]);
}
};
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableBigDecimalScore.of(hardImpacts, softImpacts),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/BendableBigDecimalScoreInliner.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.math.BigDecimal;
import java.util.Arrays;
import java.util.Map;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class BendableBigDecimalScoreInliner extends AbstractScoreInliner<BendableBigDecimalScore> {
final BigDecimal[] hardScores;
final BigDecimal[] softScores;
BendableBigDecimalScoreInliner(Map<Constraint, BendableBigDecimalScore> constraintWeightMap,
ConstraintMatchPolicy constraintMatchPolicy, int hardLevelsSize, int softLevelsSize) {
super(constraintWeightMap, constraintMatchPolicy);
hardScores = new BigDecimal[hardLevelsSize];
Arrays.fill(hardScores, BigDecimal.ZERO);
softScores = new BigDecimal[softLevelsSize];
Arrays.fill(softScores, BigDecimal.ZERO);
}
@Override
public WeightedScoreImpacter<BendableBigDecimalScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
Integer singleLevel = null;
BendableBigDecimalScore constraintWeight = constraintWeightMap.get(constraint);
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (!constraintWeight.hardOrSoftScore(i).equals(BigDecimal.ZERO)) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableBigDecimalScoreContext context = new BendableBigDecimalScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel));
if (isHardScore) {
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeHardScoreBy);
} else {
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeSoftScoreBy);
}
} else {
BendableBigDecimalScoreContext context = new BendableBigDecimalScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length);
return WeightedScoreImpacter.of(context, BendableBigDecimalScoreContext::changeScoreBy);
}
}
@Override
public BendableBigDecimalScore extractScore() {
return BendableBigDecimalScore.of(Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/BendableLongScoreContext.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class BendableLongScoreContext extends ScoreContext<BendableLongScore, BendableLongScoreInliner> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final long scoreLevelWeight;
public BendableLongScoreContext(BendableLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableLongScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
long scoreLevelWeight) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
}
public BendableLongScoreContext(BendableLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableLongScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, -1);
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) {
long softImpact = scoreLevelWeight * matchWeight;
parent.softScores[scoreLevel] += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScores[scoreLevel] -= softImpact;
;
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableLongScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) {
long hardImpact = scoreLevelWeight * matchWeight;
parent.hardScores[scoreLevel] += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScores[scoreLevel] -= hardImpact;
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableLongScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) {
long[] hardImpacts = new long[hardScoreLevelCount];
long[] softImpacts = new long[softScoreLevelCount];
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
long hardImpact = constraintWeight.hardScore(hardScoreLevel) * matchWeight;
hardImpacts[hardScoreLevel] = hardImpact;
parent.hardScores[hardScoreLevel] += hardImpact;
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
long softImpact = constraintWeight.softScore(softScoreLevel) * matchWeight;
softImpacts[softScoreLevel] = softImpact;
parent.softScores[softScoreLevel] += softImpact;
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
parent.hardScores[hardScoreLevel] -= hardImpacts[hardScoreLevel];
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
parent.softScores[softScoreLevel] -= softImpacts[softScoreLevel];
}
};
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableLongScore.of(hardImpacts, softImpacts),
constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/BendableLongScoreInliner.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.util.Arrays;
import java.util.Map;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
public final class BendableLongScoreInliner extends AbstractScoreInliner<BendableLongScore> {
final long[] hardScores;
final long[] softScores;
BendableLongScoreInliner(Map<Constraint, BendableLongScore> constraintWeightMap,
ConstraintMatchPolicy constraintMatchPolicy,
int hardLevelsSize, int softLevelsSize) {
super(constraintWeightMap, constraintMatchPolicy);
hardScores = new long[hardLevelsSize];
softScores = new long[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableLongScore, ?> buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
Integer singleLevel = null;
BendableLongScore constraintWeight = constraintWeightMap.get(constraint);
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableLongScoreContext context = new BendableLongScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel));
if (isHardScore) {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) -> ctx.changeHardScoreBy(impact,
constraintMatchSupplier));
} else {
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) -> ctx.changeSoftScoreBy(impact,
constraintMatchSupplier));
}
} else {
BendableLongScoreContext context =
new BendableLongScoreContext(this, constraint, constraintWeight, hardScores.length, softScores.length);
return WeightedScoreImpacter.of(context, (BendableLongScoreContext ctx, long impact,
ConstraintMatchSupplier<BendableLongScore> constraintMatchSupplier) -> ctx.changeScoreBy(impact,
constraintMatchSupplier));
}
}
@Override
public BendableLongScore extractScore() {
return BendableLongScore.of(Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableLongScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/BendableScoreContext.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class BendableScoreContext extends ScoreContext<BendableScore, BendableScoreInliner> {
private final int hardScoreLevelCount;
private final int softScoreLevelCount;
private final int scoreLevel;
private final int scoreLevelWeight;
public BendableScoreContext(BendableScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount, int scoreLevel,
int scoreLevelWeight) {
super(parent, constraint, constraintWeight);
this.hardScoreLevelCount = hardScoreLevelCount;
this.softScoreLevelCount = softScoreLevelCount;
this.scoreLevel = scoreLevel;
this.scoreLevelWeight = scoreLevelWeight;
}
public BendableScoreContext(BendableScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
BendableScore constraintWeight, int hardScoreLevelCount, int softScoreLevelCount) {
this(parent, constraint, constraintWeight, hardScoreLevelCount, softScoreLevelCount, -1, -1);
}
public UndoScoreImpacter changeSoftScoreBy(int matchWeight,
ConstraintMatchSupplier<BendableScore> constraintMatchSupplier) {
int softImpact = scoreLevelWeight * matchWeight;
parent.softScores[scoreLevel] += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScores[scoreLevel] -= softImpact;
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofSoft(hardScoreLevelCount, softScoreLevelCount, scoreLevel, softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(int matchWeight,
ConstraintMatchSupplier<BendableScore> constraintMatchSupplier) {
int hardImpact = scoreLevelWeight * matchWeight;
parent.hardScores[scoreLevel] += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScores[scoreLevel] -= hardImpact;
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
BendableScore.ofHard(hardScoreLevelCount, softScoreLevelCount, scoreLevel, hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(int matchWeight, ConstraintMatchSupplier<BendableScore> constraintMatchSupplier) {
int[] hardImpacts = new int[hardScoreLevelCount];
int[] softImpacts = new int[softScoreLevelCount];
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
int hardImpact = constraintWeight.hardScore(hardScoreLevel) * matchWeight;
hardImpacts[hardScoreLevel] = hardImpact;
parent.hardScores[hardScoreLevel] += hardImpact;
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
int softImpact = constraintWeight.softScore(softScoreLevel) * matchWeight;
softImpacts[softScoreLevel] = softImpact;
parent.softScores[softScoreLevel] += softImpact;
}
UndoScoreImpacter undoScoreImpact = () -> {
for (int hardScoreLevel = 0; hardScoreLevel < hardScoreLevelCount; hardScoreLevel++) {
parent.hardScores[hardScoreLevel] -= hardImpacts[hardScoreLevel];
}
for (int softScoreLevel = 0; softScoreLevel < softScoreLevelCount; softScoreLevel++) {
parent.softScores[softScoreLevel] -= softImpacts[softScoreLevel];
}
};
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, BendableScore.of(hardImpacts, softImpacts), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/BendableScoreInliner.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.util.Arrays;
import java.util.Map;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class BendableScoreInliner extends AbstractScoreInliner<BendableScore> {
final int[] hardScores;
final int[] softScores;
BendableScoreInliner(Map<Constraint, BendableScore> constraintWeightMap, ConstraintMatchPolicy constraintMatchPolicy,
int hardLevelsSize,
int softLevelsSize) {
super(constraintWeightMap, constraintMatchPolicy);
hardScores = new int[hardLevelsSize];
softScores = new int[softLevelsSize];
}
@Override
public WeightedScoreImpacter<BendableScore, ?> buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
Integer singleLevel = null;
BendableScore constraintWeight = constraintWeightMap.get(constraint);
for (int i = 0; i < constraintWeight.levelsSize(); i++) {
if (constraintWeight.hardOrSoftScore(i) != 0L) {
if (singleLevel != null) {
singleLevel = null;
break;
}
singleLevel = i;
}
}
if (singleLevel != null) {
boolean isHardScore = singleLevel < constraintWeight.hardLevelsSize();
int level = isHardScore ? singleLevel : singleLevel - constraintWeight.hardLevelsSize();
BendableScoreContext context = new BendableScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length, level, constraintWeight.hardOrSoftScore(singleLevel));
if (isHardScore) {
return WeightedScoreImpacter.of(context, BendableScoreContext::changeHardScoreBy);
} else {
return WeightedScoreImpacter.of(context, BendableScoreContext::changeSoftScoreBy);
}
} else {
BendableScoreContext context = new BendableScoreContext(this, constraint, constraintWeight,
hardScores.length, softScores.length);
return WeightedScoreImpacter.of(context, BendableScoreContext::changeScoreBy);
}
}
@Override
public BendableScore extractScore() {
return BendableScore.of(Arrays.copyOf(hardScores, hardScores.length),
Arrays.copyOf(softScores, softScores.length));
}
@Override
public String toString() {
return BendableScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/BigDecimalWeightedScoreImpacter.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.math.BigDecimal;
import java.util.Objects;
import ai.timefold.solver.core.api.score.Score;
final class BigDecimalWeightedScoreImpacter<Score_ extends Score<Score_>, Context_ extends ScoreContext<Score_, ?>>
implements WeightedScoreImpacter<Score_, Context_> {
private final BigDecimalImpactFunction<Score_, Context_> impactFunction;
private final Context_ context;
public BigDecimalWeightedScoreImpacter(BigDecimalImpactFunction<Score_, Context_> impactFunction,
Context_ context) {
this.impactFunction = Objects.requireNonNull(impactFunction);
this.context = context;
}
@Override
public UndoScoreImpacter impactScore(int matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, BigDecimal.valueOf(matchWeight), constraintMatchSupplier);
}
@Override
public UndoScoreImpacter impactScore(long matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, BigDecimal.valueOf(matchWeight), constraintMatchSupplier);
}
@Override
public UndoScoreImpacter impactScore(BigDecimal matchWeight, ConstraintMatchSupplier<Score_> constraintMatchSupplier) {
context.getConstraint().assertCorrectImpact(matchWeight);
return impactFunction.impact(context, matchWeight, constraintMatchSupplier);
}
@Override
public Context_ getContext() {
return context;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/ConstraintMatchSupplier.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.util.Arrays;
import java.util.Collection;
import java.util.Collections;
import java.util.Objects;
import java.util.function.BiFunction;
import java.util.function.Function;
import java.util.stream.Collectors;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.constraint.ConstraintMatch;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
/**
* Allows creating {@link ConstraintMatch} instances lazily if and only if they are required by the end user.
* <p>
* Lazy behavior is important for constraint matching performance.
* In order to create {@link ConstraintMatch}, an entire {@link ConstraintJustification} object needs to be created,
* along with the collection of indicted objects.
* Creating these structures every time a constraint is matched would be wasteful,
* as the same constraint match can be undone almost immediately, resulting in a lot of pointless garbage.
* Therefore, {@link ConstraintMatch} (along with all of its supporting data structures)
* is only created when actually needed, and that is during score explanation.
* Until that point, this thin wrapper serves as a placeholder which understands what to create when needed.
*/
@FunctionalInterface
public interface ConstraintMatchSupplier<Score_ extends Score<Score_>>
extends BiFunction<Constraint, Score_, ConstraintMatch<Score_>> {
/**
*
* @return the constraint match returned by the supplier will have its justification set to null.
* This is useful when the justifications are disabled, to save memory.
* @param <Score_>
*/
static <Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> empty() {
return (constraint, impact) -> new ConstraintMatch<>(constraint.getConstraintRef(), null, Collections.emptyList(),
impact);
}
static <A, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
BiFunction<A, Score<?>, ConstraintJustification> justificationMapping,
Function<A, Collection<Object>> indictedObjectsMapping,
A a) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
private static RuntimeException createJustificationException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintRef()
+ ") threw an exception creating constraint justification from a tuple (" + factsToString(facts) + ").", cause);
}
private static String factsToString(Object... facts) {
return Arrays.stream(facts)
.map(Objects::toString)
.collect(Collectors.joining(", ", "{", "}"));
}
private static RuntimeException createIndictmentException(Constraint constraint, Exception cause, Object... facts) {
throw new IllegalStateException("Consequence of a constraint (" + constraint.getConstraintRef()
+ ") threw an exception collecting indicted objects from a tuple (" + factsToString(facts) + ").", cause);
}
static <A, B, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
TriFunction<A, B, Score_, ConstraintJustification> justificationMapping,
BiFunction<A, B, Collection<Object>> indictedObjectsMapping,
A a, B b) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, b, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a, b);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
static <A, B, C, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
QuadFunction<A, B, C, Score_, ConstraintJustification> justificationMapping,
TriFunction<A, B, C, Collection<Object>> indictedObjectsMapping,
A a, B b, C c) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, b, c, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a, b, c);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
static <A, B, C, D, Score_ extends Score<Score_>> ConstraintMatchSupplier<Score_> of(
PentaFunction<A, B, C, D, Score_, ConstraintJustification> justificationMapping,
QuadFunction<A, B, C, D, Collection<Object>> indictedObjectsMapping,
A a, B b, C c, D d) {
return (constraint, impact) -> {
ConstraintJustification justification;
try {
justification = justificationMapping.apply(a, b, c, d, impact);
} catch (Exception e) {
throw createJustificationException(constraint, e, a, b, c, d);
}
Collection<Object> indictedObjectCollection;
try {
indictedObjectCollection = indictedObjectsMapping.apply(a, b, c, d);
} catch (Exception e) {
throw createIndictmentException(constraint, e, a, b, c, d);
}
return new ConstraintMatch<>(constraint.getConstraintRef(), justification, indictedObjectCollection, impact);
};
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/HardMediumSoftBigDecimalScoreContext.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.math.BigDecimal;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class HardMediumSoftBigDecimalScoreContext
extends ScoreContext<HardMediumSoftBigDecimalScore, HardMediumSoftBigDecimalScoreInliner> {
public HardMediumSoftBigDecimalScoreContext(HardMediumSoftBigDecimalScoreInliner parent,
AbstractConstraint<?, ?, ?> constraint, HardMediumSoftBigDecimalScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
parent.softScore = parent.softScore.add(softImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.softScore = parent.softScore.subtract(softImpact);
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofSoft(softImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
parent.mediumScore = parent.mediumScore.add(mediumImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.mediumScore = parent.mediumScore.subtract(mediumImpact);
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofMedium(mediumImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
parent.hardScore = parent.hardScore.add(hardImpact);
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore = parent.hardScore.subtract(hardImpact);
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftBigDecimalScore.ofHard(hardImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(BigDecimal matchWeight,
ConstraintMatchSupplier<HardMediumSoftBigDecimalScore> constraintMatchSupplier) {
BigDecimal hardImpact = constraintWeight.hardScore().multiply(matchWeight);
BigDecimal mediumImpact = constraintWeight.mediumScore().multiply(matchWeight);
BigDecimal softImpact = constraintWeight.softScore().multiply(matchWeight);
parent.hardScore = parent.hardScore.add(hardImpact);
parent.mediumScore = parent.mediumScore.add(mediumImpact);
parent.softScore = parent.softScore.add(softImpact);
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore = parent.hardScore.subtract(hardImpact);
parent.mediumScore = parent.mediumScore.subtract(mediumImpact);
parent.softScore = parent.softScore.subtract(softImpact);
};
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact,
HardMediumSoftBigDecimalScore.of(hardImpact, mediumImpact, softImpact), constraintMatchSupplier);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/HardMediumSoftBigDecimalScoreInliner.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import java.math.BigDecimal;
import java.util.Map;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.impl.score.constraint.ConstraintMatchPolicy;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class HardMediumSoftBigDecimalScoreInliner extends AbstractScoreInliner<HardMediumSoftBigDecimalScore> {
BigDecimal hardScore = BigDecimal.ZERO;
BigDecimal mediumScore = BigDecimal.ZERO;
BigDecimal softScore = BigDecimal.ZERO;
HardMediumSoftBigDecimalScoreInliner(Map<Constraint, HardMediumSoftBigDecimalScore> constraintWeightMap,
ConstraintMatchPolicy constraintMatchPolicy) {
super(constraintWeightMap, constraintMatchPolicy);
}
@Override
public WeightedScoreImpacter<HardMediumSoftBigDecimalScore, ?>
buildWeightedScoreImpacter(AbstractConstraint<?, ?, ?> constraint) {
HardMediumSoftBigDecimalScore constraintWeight = constraintWeightMap.get(constraint);
BigDecimal hardConstraintWeight = constraintWeight.hardScore();
BigDecimal mediumConstraintWeight = constraintWeight.mediumScore();
BigDecimal softConstraintWeight = constraintWeight.softScore();
HardMediumSoftBigDecimalScoreContext context =
new HardMediumSoftBigDecimalScoreContext(this, constraint, constraintWeight);
if (mediumConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeHardScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && softConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeMediumScoreBy);
} else if (hardConstraintWeight.equals(BigDecimal.ZERO) && mediumConstraintWeight.equals(BigDecimal.ZERO)) {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeSoftScoreBy);
} else {
return WeightedScoreImpacter.of(context, HardMediumSoftBigDecimalScoreContext::changeScoreBy);
}
}
@Override
public HardMediumSoftBigDecimalScore extractScore() {
return HardMediumSoftBigDecimalScore.of(hardScore, mediumScore, softScore);
}
@Override
public String toString() {
return HardMediumSoftBigDecimalScore.class.getSimpleName() + " inliner";
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common | java-sources/ai/timefold/solver/timefold-solver-core/1.26.1/ai/timefold/solver/core/impl/score/stream/common/inliner/HardMediumSoftLongScoreContext.java | package ai.timefold.solver.core.impl.score.stream.common.inliner;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.core.impl.score.stream.common.AbstractConstraint;
final class HardMediumSoftLongScoreContext extends ScoreContext<HardMediumSoftLongScore, HardMediumSoftLongScoreInliner> {
public HardMediumSoftLongScoreContext(HardMediumSoftLongScoreInliner parent, AbstractConstraint<?, ?, ?> constraint,
HardMediumSoftLongScore constraintWeight) {
super(parent, constraint, constraintWeight);
}
public UndoScoreImpacter changeSoftScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long softImpact = constraintWeight.softScore() * matchWeight;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.softScore -= softImpact;
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofSoft(softImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeMediumScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
parent.mediumScore += mediumImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.mediumScore -= mediumImpact;
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofMedium(mediumImpact),
constraintMatchSupplier);
}
public UndoScoreImpacter changeHardScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
parent.hardScore += hardImpact;
UndoScoreImpacter undoScoreImpact = () -> parent.hardScore -= hardImpact;
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.ofHard(hardImpact), constraintMatchSupplier);
}
public UndoScoreImpacter changeScoreBy(long matchWeight,
ConstraintMatchSupplier<HardMediumSoftLongScore> constraintMatchSupplier) {
long hardImpact = constraintWeight.hardScore() * matchWeight;
long mediumImpact = constraintWeight.mediumScore() * matchWeight;
long softImpact = constraintWeight.softScore() * matchWeight;
parent.hardScore += hardImpact;
parent.mediumScore += mediumImpact;
parent.softScore += softImpact;
UndoScoreImpacter undoScoreImpact = () -> {
parent.hardScore -= hardImpact;
parent.mediumScore -= mediumImpact;
parent.softScore -= softImpact;
};
if (!constraintMatchPolicy.isEnabled()) {
return undoScoreImpact;
}
return impactWithConstraintMatch(undoScoreImpact, HardMediumSoftLongScore.of(hardImpact, mediumImpact, softImpact),
constraintMatchSupplier);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.