index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ConditionalQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.function.QuadPredicate;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
final class ConditionalQuadCollector<A, B, C, D, ResultContainer_, Result_>
implements QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> {
private final QuadPredicate<A, B, C, D> predicate;
private final QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> delegate;
private final PentaFunction<ResultContainer_, A, B, C, D, Runnable> innerAccumulator;
ConditionalQuadCollector(QuadPredicate<A, B, C, D> predicate,
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> delegate) {
this.predicate = predicate;
this.delegate = delegate;
this.innerAccumulator = delegate.accumulator();
}
@Override
public Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public PentaFunction<ResultContainer_, A, B, C, D, Runnable> accumulator() {
return (resultContainer, a, b, c, d) -> {
if (predicate.test(a, b, c, d)) {
return innerAccumulator.apply(resultContainer, a, b, c, d);
} else {
return ConstantLambdaUtils.noop();
}
};
}
@Override
public 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 = (ConditionalQuadCollector<?, ?, ?, ?, ?, ?>) 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ConsecutiveSequencesQuadConstraintCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.Objects;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import ai.timefold.solver.core.impl.score.stream.SequenceCalculator;
final class ConsecutiveSequencesQuadConstraintCollector<A, B, C, D, Result_>
extends
ObjectCalculatorQuadCollector<A, B, C, D, Result_, SequenceChain<Result_, Integer>, SequenceCalculator<Result_>> {
private final ToIntFunction<Result_> indexMap;
public ConsecutiveSequencesQuadConstraintCollector(QuadFunction<A, B, C, D, Result_> resultMap,
ToIntFunction<Result_> indexMap) {
super(resultMap);
this.indexMap = Objects.requireNonNull(indexMap);
}
@Override
public Supplier<SequenceCalculator<Result_>> supplier() {
return () -> new SequenceCalculator<>(indexMap);
}
@Override
public boolean equals(Object o) {
if (o instanceof ConsecutiveSequencesQuadConstraintCollector<?, ?, ?, ?, ?> 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/CountDistinctIntQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.IntDistinctCountCalculator;
final class CountDistinctIntQuadCollector<A, B, C, D, Mapped_>
extends ObjectCalculatorQuadCollector<A, B, C, D, Mapped_, Integer, IntDistinctCountCalculator<Mapped_>> {
CountDistinctIntQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<IntDistinctCountCalculator<Mapped_>> supplier() {
return IntDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/CountDistinctLongQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.LongDistinctCountCalculator;
final class CountDistinctLongQuadCollector<A, B, C, D, Mapped_>
extends ObjectCalculatorQuadCollector<A, B, C, D, Mapped_, Long, LongDistinctCountCalculator<Mapped_>> {
CountDistinctLongQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<LongDistinctCountCalculator<Mapped_>> supplier() {
return LongDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/CountIntQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.IntCounter;
final class CountIntQuadCollector<A, B, C, D> implements QuadConstraintCollector<A, B, C, D, IntCounter, Integer> {
private final static CountIntQuadCollector<?, ?, ?, ?> INSTANCE = new CountIntQuadCollector<>();
private CountIntQuadCollector() {
}
@SuppressWarnings("unchecked")
static <A, B, C, D> CountIntQuadCollector<A, B, C, D> getInstance() {
return (CountIntQuadCollector<A, B, C, D>) INSTANCE;
}
@Override
public Supplier<IntCounter> supplier() {
return IntCounter::new;
}
@Override
public PentaFunction<IntCounter, A, B, C, D, Runnable> accumulator() {
return (counter, a, b, c, d) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public Function<IntCounter, Integer> finisher() {
return IntCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/CountLongQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.PentaFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.LongCounter;
final class CountLongQuadCollector<A, B, C, D> implements QuadConstraintCollector<A, B, C, D, LongCounter, Long> {
private final static CountLongQuadCollector<?, ?, ?, ?> INSTANCE = new CountLongQuadCollector<>();
private CountLongQuadCollector() {
}
@SuppressWarnings("unchecked")
static <A, B, C, D> CountLongQuadCollector<A, B, C, D> getInstance() {
return (CountLongQuadCollector<A, B, C, D>) INSTANCE;
}
@Override
public Supplier<LongCounter> supplier() {
return LongCounter::new;
}
@Override
public PentaFunction<LongCounter, A, B, C, D, Runnable> accumulator() {
return (counter, a, b, c, d) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public Function<LongCounter, Long> finisher() {
return LongCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/InnerQuadConstraintCollectors.java | package ai.timefold.solver.core.impl.score.stream.quad;
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.QuadPredicate;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.ReferenceAverageCalculator;
public class InnerQuadConstraintCollectors {
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, Double> average(
ToIntQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
return new AverageIntQuadCollector<>(mapper);
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, Double> average(
ToLongQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
return new AverageLongQuadCollector<>(mapper);
}
static <A, B, C, D, Mapped_, Average_> QuadConstraintCollector<A, B, C, D, ?, Average_> average(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper,
Supplier<ReferenceAverageCalculator<Mapped_, Average_>> calculatorSupplier) {
return new AverageReferenceQuadCollector<>(mapper, calculatorSupplier);
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, BigDecimal> averageBigDecimal(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends BigDecimal> mapper) {
return average(mapper, ReferenceAverageCalculator.bigDecimal());
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, BigDecimal> averageBigInteger(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends BigInteger> mapper) {
return average(mapper, ReferenceAverageCalculator.bigInteger());
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, Duration> averageDuration(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Duration> mapper) {
return average(mapper, ReferenceAverageCalculator.duration());
}
public static <A, B, C, D, ResultHolder1_, ResultHolder2_, ResultHolder3_, ResultHolder4_, Result1_, Result2_, Result3_, Result4_, Result_>
QuadConstraintCollector<A, B, C, D, ?, Result_>
compose(
QuadConstraintCollector<A, B, C, D, ResultHolder1_, Result1_> first,
QuadConstraintCollector<A, B, C, D, ResultHolder2_, Result2_> second,
QuadConstraintCollector<A, B, C, D, ResultHolder3_, Result3_> third,
QuadConstraintCollector<A, B, C, D, ResultHolder4_, Result4_> fourth,
QuadFunction<Result1_, Result2_, Result3_, Result4_, Result_> composeFunction) {
return new ComposeFourQuadCollector<>(
first, second, third, fourth, composeFunction);
}
public static <A, B, C, D, ResultHolder1_, ResultHolder2_, ResultHolder3_, Result1_, Result2_, Result3_, Result_>
QuadConstraintCollector<A, B, C, D, ?, Result_>
compose(
QuadConstraintCollector<A, B, C, D, ResultHolder1_, Result1_> first,
QuadConstraintCollector<A, B, C, D, ResultHolder2_, Result2_> second,
QuadConstraintCollector<A, B, C, D, ResultHolder3_, Result3_> third,
TriFunction<Result1_, Result2_, Result3_, Result_> composeFunction) {
return new ComposeThreeQuadCollector<>(
first, second, third, composeFunction);
}
public static <A, B, C, D, ResultHolder1_, ResultHolder2_, Result1_, Result2_, Result_>
QuadConstraintCollector<A, B, C, D, ?, Result_> compose(
QuadConstraintCollector<A, B, C, D, ResultHolder1_, Result1_> first,
QuadConstraintCollector<A, B, C, D, ResultHolder2_, Result2_> second,
BiFunction<Result1_, Result2_, Result_> composeFunction) {
return new ComposeTwoQuadCollector<>(first,
second, composeFunction);
}
public static <A, B, C, D, ResultContainer_, Result_> QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_>
conditionally(
QuadPredicate<A, B, C, D> predicate,
QuadConstraintCollector<A, B, C, D, ResultContainer_, Result_> delegate) {
return new ConditionalQuadCollector<>(predicate, delegate);
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, Integer> count() {
return CountIntQuadCollector.getInstance();
}
public static <A, B, C, D, Mapped_> QuadConstraintCollector<A, B, C, D, ?, Integer> countDistinct(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
return new CountDistinctIntQuadCollector<>(mapper);
}
public static <A, B, C, D, Mapped_> QuadConstraintCollector<A, B, C, D, ?, Long> countDistinctLong(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
return new CountDistinctLongQuadCollector<>(mapper);
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, Long> countLong() {
return CountLongQuadCollector.getInstance();
}
public static <A, B, C, D, Result_ extends Comparable<? super Result_>> QuadConstraintCollector<A, B, C, D, ?, Result_> max(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper) {
return new MaxComparableQuadCollector<>(mapper);
}
public static <A, B, C, D, Result_> QuadConstraintCollector<A, B, C, D, ?, Result_> max(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
return new MaxComparatorQuadCollector<>(mapper, comparator);
}
public static <A, B, C, D, Result_, Property_ extends Comparable<? super Property_>>
QuadConstraintCollector<A, B, C, D, ?, Result_> max(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
return new MaxPropertyQuadCollector<>(mapper, propertyMapper);
}
public static <A, B, C, D, Result_ extends Comparable<? super Result_>> QuadConstraintCollector<A, B, C, D, ?, Result_> min(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper) {
return new MinComparableQuadCollector<>(mapper);
}
public static <A, B, C, D, Result_> QuadConstraintCollector<A, B, C, D, ?, Result_> min(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
return new MinComparatorQuadCollector<>(mapper, comparator);
}
public static <A, B, C, D, Result_, Property_ extends Comparable<? super Property_>>
QuadConstraintCollector<A, B, C, D, ?, Result_> min(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
return new MinPropertyQuadCollector<>(mapper, propertyMapper);
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, Integer> sum(
ToIntQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
return new SumIntQuadCollector<>(mapper);
}
public static <A, B, C, D> QuadConstraintCollector<A, B, C, D, ?, Long> sum(
ToLongQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
return new SumLongQuadCollector<>(mapper);
}
public static <A, B, C, D, Result_> QuadConstraintCollector<A, B, C, D, ?, Result_> sum(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Result_ zero,
BinaryOperator<Result_> adder,
BinaryOperator<Result_> subtractor) {
return new SumReferenceQuadCollector<>(mapper, zero, adder, subtractor);
}
public static <A, B, C, D, Mapped_, Result_ extends Collection<Mapped_>>
QuadConstraintCollector<A, B, C, D, ?, Result_> toCollection(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper,
IntFunction<Result_> collectionFunction) {
return new ToCollectionQuadCollector<>(mapper, collectionFunction);
}
public static <A, B, C, D, Mapped_> QuadConstraintCollector<A, B, C, D, ?, List<Mapped_>> toList(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
return new ToListQuadCollector<>(mapper);
}
public static <A, B, C, D, Key_, Value_, Set_ extends Set<Value_>, Result_ extends Map<Key_, Set_>>
QuadConstraintCollector<A, B, C, D, ?, Result_> toMap(
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) {
return new ToMultiMapQuadCollector<>(keyFunction, valueFunction, mapSupplier,
setFunction);
}
public static <A, B, C, D, Key_, Value_, Result_ extends Map<Key_, Value_>>
QuadConstraintCollector<A, B, C, D, ?, Result_> toMap(
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) {
return new ToSimpleMapQuadCollector<>(keyFunction, valueFunction, mapSupplier,
mergeFunction);
}
public static <A, B, C, D, Mapped_> QuadConstraintCollector<A, B, C, D, ?, Set<Mapped_>> toSet(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper) {
return new ToSetQuadCollector<>(mapper);
}
public static <A, B, C, D, Mapped_> QuadConstraintCollector<A, B, C, D, ?, SortedSet<Mapped_>> toSortedSet(
QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper,
Comparator<? super Mapped_> comparator) {
return new ToSortedSetComparatorQuadCollector<>(mapper, comparator);
}
public static <A, B, C, D, Result_> QuadConstraintCollector<A, B, C, D, ?, SequenceChain<Result_, Integer>>
toConsecutiveSequences(QuadFunction<A, B, C, D, Result_> resultMap, ToIntFunction<Result_> indexMap) {
return new ConsecutiveSequencesQuadConstraintCollector<>(resultMap, indexMap);
}
public static <A, B, C, D, Intermediate_, Result_> QuadConstraintCollector<A, B, C, D, ?, Result_>
collectAndThen(QuadConstraintCollector<A, B, C, D, ?, Intermediate_> delegate,
Function<Intermediate_, Result_> mappingFunction) {
return new AndThenQuadCollector<>(delegate, mappingFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/IntCalculatorQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ToIntQuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.IntCalculator;
abstract sealed class IntCalculatorQuadCollector<A, B, C, D, Output_, Calculator_ extends IntCalculator<Output_>>
implements QuadConstraintCollector<A, B, C, D, Calculator_, Output_>
permits AverageIntQuadCollector, SumIntQuadCollector {
private final ToIntQuadFunction<? super A, ? super B, ? super C, ? super D> mapper;
public IntCalculatorQuadCollector(ToIntQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
this.mapper = mapper;
}
@Override
public PentaFunction<Calculator_, A, B, C, D, Runnable> accumulator() {
return (calculator, a, b, c, d) -> {
final int mapped = mapper.applyAsInt(a, b, c, d);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public 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 = (IntCalculatorQuadCollector<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/LongCalculatorQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ToLongQuadFunction;
import ai.timefold.solver.core.api.score.stream.quad.QuadConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.LongCalculator;
abstract sealed class LongCalculatorQuadCollector<A, B, C, D, Output_, Calculator_ extends LongCalculator<Output_>>
implements QuadConstraintCollector<A, B, C, D, Calculator_, Output_>
permits AverageLongQuadCollector, SumLongQuadCollector {
private final ToLongQuadFunction<? super A, ? super B, ? super C, ? super D> mapper;
public LongCalculatorQuadCollector(ToLongQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
this.mapper = mapper;
}
@Override
public PentaFunction<Calculator_, A, B, C, D, Runnable> accumulator() {
return (calculator, a, b, c, d) -> {
final long mapped = mapper.applyAsLong(a, b, c, d);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public 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 = (LongCalculatorQuadCollector<?, ?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/MaxComparableQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
final class MaxComparableQuadCollector<A, B, C, D, Result_ extends Comparable<? super Result_>>
extends UndoableActionableQuadCollector<A, B, C, D, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
MaxComparableQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper) {
super(mapper);
}
@Override
public Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::maxCalculator;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/MaxComparatorQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
final class MaxComparatorQuadCollector<A, B, C, D, Result_>
extends UndoableActionableQuadCollector<A, B, C, D, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
private final Comparator<? super Result_> comparator;
MaxComparatorQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public 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;
MaxComparatorQuadCollector<?, ?, ?, ?, ?> that = (MaxComparatorQuadCollector<?, ?, ?, ?, ?>) 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/MaxPropertyQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
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.impl.score.stream.MinMaxUndoableActionable;
final class MaxPropertyQuadCollector<A, B, C, D, Result_, Property_ extends Comparable<? super Property_>>
extends UndoableActionableQuadCollector<A, B, C, D, Result_, Result_, MinMaxUndoableActionable<Result_, Property_>> {
private final Function<? super Result_, ? extends Property_> propertyMapper;
MaxPropertyQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
super(mapper);
this.propertyMapper = propertyMapper;
}
@Override
public 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;
MaxPropertyQuadCollector<?, ?, ?, ?, ?, ?> that = (MaxPropertyQuadCollector<?, ?, ?, ?, ?, ?>) 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/MinComparableQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
final class MinComparableQuadCollector<A, B, C, D, Result_ extends Comparable<? super Result_>>
extends UndoableActionableQuadCollector<A, B, C, D, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
MinComparableQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper) {
super(mapper);
}
@Override
public Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::minCalculator;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/MinComparatorQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.Comparator;
import java.util.Objects;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
final class MinComparatorQuadCollector<A, B, C, D, Result_>
extends UndoableActionableQuadCollector<A, B, C, D, Result_, Result_, MinMaxUndoableActionable<Result_, Result_>> {
private final Comparator<? super Result_> comparator;
MinComparatorQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Comparator<? super Result_> comparator) {
super(mapper);
this.comparator = comparator;
}
@Override
public 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;
MinComparatorQuadCollector<?, ?, ?, ?, ?> that = (MinComparatorQuadCollector<?, ?, ?, ?, ?>) 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/MinPropertyQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
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.impl.score.stream.MinMaxUndoableActionable;
final class MinPropertyQuadCollector<A, B, C, D, Result_, Property_ extends Comparable<? super Property_>>
extends UndoableActionableQuadCollector<A, B, C, D, Result_, Result_, MinMaxUndoableActionable<Result_, Property_>> {
private final Function<? super Result_, ? extends Property_> propertyMapper;
MinPropertyQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Function<? super Result_, ? extends Property_> propertyMapper) {
super(mapper);
this.propertyMapper = propertyMapper;
}
@Override
public 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;
MinPropertyQuadCollector<?, ?, ?, ?, ?, ?> that = (MinPropertyQuadCollector<?, ?, ?, ?, ?, ?>) 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ObjectCalculatorQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ObjectCalculator;
abstract sealed class ObjectCalculatorQuadCollector<A, B, C, D, Input_, Output_, Calculator_ extends ObjectCalculator<Input_, Output_>>
implements QuadConstraintCollector<A, B, C, D, Calculator_, Output_>
permits AverageReferenceQuadCollector, ConsecutiveSequencesQuadConstraintCollector, CountDistinctIntQuadCollector,
CountDistinctLongQuadCollector, SumReferenceQuadCollector {
protected final QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Input_> mapper;
public ObjectCalculatorQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Input_> mapper) {
this.mapper = mapper;
}
@Override
public PentaFunction<Calculator_, A, B, C, D, Runnable> accumulator() {
return (calculator, a, b, c, d) -> {
final Input_ mapped = mapper.apply(a, b, c, d);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public 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 = (ObjectCalculatorQuadCollector<?, ?, ?, ?, ?, ?, ?>) object;
return Objects.equals(mapper, that.mapper);
}
@Override
public int hashCode() {
return Objects.hash(mapper);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/SumIntQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToIntQuadFunction;
import ai.timefold.solver.core.impl.score.stream.IntSumCalculator;
final class SumIntQuadCollector<A, B, C, D> extends IntCalculatorQuadCollector<A, B, C, D, Integer, IntSumCalculator> {
SumIntQuadCollector(ToIntQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
super(mapper);
}
@Override
public Supplier<IntSumCalculator> supplier() {
return IntSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/SumLongQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToLongQuadFunction;
import ai.timefold.solver.core.impl.score.stream.LongSumCalculator;
final class SumLongQuadCollector<A, B, C, D> extends LongCalculatorQuadCollector<A, B, C, D, Long, LongSumCalculator> {
SumLongQuadCollector(ToLongQuadFunction<? super A, ? super B, ? super C, ? super D> mapper) {
super(mapper);
}
@Override
public Supplier<LongSumCalculator> supplier() {
return LongSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/SumReferenceQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
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.ReferenceSumCalculator;
final class SumReferenceQuadCollector<A, B, C, D, Result_>
extends ObjectCalculatorQuadCollector<A, B, C, D, Result_, Result_, ReferenceSumCalculator<Result_>> {
private final Result_ zero;
private final BinaryOperator<Result_> adder;
private final BinaryOperator<Result_> subtractor;
SumReferenceQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Result_> mapper,
Result_ zero,
BinaryOperator<Result_> adder,
BinaryOperator<Result_> subtractor) {
super(mapper);
this.zero = zero;
this.adder = adder;
this.subtractor = subtractor;
}
@Override
public 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;
SumReferenceQuadCollector<?, ?, ?, ?, ?> that = (SumReferenceQuadCollector<?, ?, ?, ?, ?>) 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ToCollectionQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.quad;
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.QuadFunction;
import ai.timefold.solver.core.impl.score.stream.CustomCollectionUndoableActionable;
final class ToCollectionQuadCollector<A, B, C, D, Mapped_, Result_ extends Collection<Mapped_>>
extends
UndoableActionableQuadCollector<A, B, C, D, Mapped_, Result_, CustomCollectionUndoableActionable<Mapped_, Result_>> {
private final IntFunction<Result_> collectionFunction;
ToCollectionQuadCollector(QuadFunction<? super A, ? super B, ? super C, ? super D, ? extends Mapped_> mapper,
IntFunction<Result_> collectionFunction) {
super(mapper);
this.collectionFunction = collectionFunction;
}
@Override
public 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;
ToCollectionQuadCollector<?, ?, ?, ?, ?, ?> that = (ToCollectionQuadCollector<?, ?, ?, ?, ?, ?>) 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ToListQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ListUndoableActionable;
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 Supplier<ListUndoableActionable<Mapped_>> supplier() {
return ListUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ToMultiMapQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ToSetQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.SetUndoableActionable;
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 Supplier<SetUndoableActionable<Mapped_>> supplier() {
return SetUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ToSimpleMapQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/ToSortedSetComparatorQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.SortedSetUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/quad/UndoableActionableQuadCollector.java | package ai.timefold.solver.core.impl.score.stream.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.UndoableActionable;
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 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/AndThenTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public QuadFunction<ResultContainer_, A, B, C, Runnable> accumulator() {
return delegate.accumulator();
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/AverageIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.impl.score.stream.IntAverageCalculator;
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 Supplier<IntAverageCalculator> supplier() {
return IntAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/AverageLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.impl.score.stream.LongAverageCalculator;
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 Supplier<LongAverageCalculator> supplier() {
return LongAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/AverageReferenceTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ReferenceAverageCalculator;
final class AverageReferenceTriCollector<A, B, C, Mapped_, Average_>
extends ObjectCalculatorTriCollector<A, B, C, Mapped_, Average_, 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ComposeFourTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 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 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ComposeThreeTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>> supplier() {
return () -> {
ResultHolder1_ a = firstSupplier.get();
ResultHolder2_ b = secondSupplier.get();
return new Triple<>(a, b, thirdSupplier.get());
};
}
@Override
public 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ComposeTwoTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<Pair<ResultHolder1_, ResultHolder2_>> supplier() {
return () -> new Pair<>(firstSupplier.get(), secondSupplier.get());
}
@Override
public 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ConditionalTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ConsecutiveSequencesTriConstraintCollector.java | package ai.timefold.solver.core.impl.score.stream.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.SequenceCalculator;
final class ConsecutiveSequencesTriConstraintCollector<A, B, C, Result_>
extends
ObjectCalculatorTriCollector<A, B, C, Result_, SequenceChain<Result_, Integer>, 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/CountDistinctIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.IntDistinctCountCalculator;
final class CountDistinctIntTriCollector<A, B, C, Mapped_>
extends ObjectCalculatorTriCollector<A, B, C, Mapped_, Integer, IntDistinctCountCalculator<Mapped_>> {
CountDistinctIntTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<IntDistinctCountCalculator<Mapped_>> supplier() {
return IntDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/CountDistinctLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.LongDistinctCountCalculator;
final class CountDistinctLongTriCollector<A, B, C, Mapped_>
extends ObjectCalculatorTriCollector<A, B, C, Mapped_, Long, LongDistinctCountCalculator<Mapped_>> {
CountDistinctLongTriCollector(TriFunction<? super A, ? super B, ? super C, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<LongDistinctCountCalculator<Mapped_>> supplier() {
return LongDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/CountIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.IntCounter;
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 Supplier<IntCounter> supplier() {
return IntCounter::new;
}
@Override
public QuadFunction<IntCounter, A, B, C, Runnable> accumulator() {
return (counter, a, b, c) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public Function<IntCounter, Integer> finisher() {
return IntCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/CountLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.LongCounter;
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 Supplier<LongCounter> supplier() {
return LongCounter::new;
}
@Override
public QuadFunction<LongCounter, A, B, C, Runnable> accumulator() {
return (counter, a, b, c) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public Function<LongCounter, Long> finisher() {
return LongCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/InnerTriConstraintCollectors.java | package ai.timefold.solver.core.impl.score.stream.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.SequenceChain;
import ai.timefold.solver.core.api.score.stream.tri.TriConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.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, Intermediate_, Result_> TriConstraintCollector<A, B, C, ?, Result_>
collectAndThen(TriConstraintCollector<A, B, C, ?, Intermediate_> delegate,
Function<Intermediate_, Result_> mappingFunction) {
return new AndThenTriCollector<>(delegate, mappingFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/IntCalculatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.IntCalculator;
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 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/LongCalculatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.LongCalculator;
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 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/MaxComparableTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
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 Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::maxCalculator;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/MaxComparatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/MaxPropertyTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/MinComparableTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.TriFunction;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
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 Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::minCalculator;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/MinComparatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/MinPropertyTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ObjectCalculatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ObjectCalculator;
abstract sealed class ObjectCalculatorTriCollector<A, B, C, Input_, Output_, Calculator_ extends ObjectCalculator<Input_, Output_>>
implements TriConstraintCollector<A, B, C, Calculator_, Output_>
permits AverageReferenceTriCollector, 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 QuadFunction<Calculator_, A, B, C, Runnable> accumulator() {
return (calculator, a, b, c) -> {
final Input_ mapped = mapper.apply(a, b, c);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/SumIntTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToIntTriFunction;
import ai.timefold.solver.core.impl.score.stream.IntSumCalculator;
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 Supplier<IntSumCalculator> supplier() {
return IntSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/SumLongTriCollector.java | package ai.timefold.solver.core.impl.score.stream.tri;
import java.util.function.Supplier;
import ai.timefold.solver.core.api.function.ToLongTriFunction;
import ai.timefold.solver.core.impl.score.stream.LongSumCalculator;
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 Supplier<LongSumCalculator> supplier() {
return LongSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/SumReferenceTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ReferenceSumCalculator;
final class SumReferenceTriCollector<A, B, C, Result_>
extends ObjectCalculatorTriCollector<A, B, C, 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ToCollectionTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.CustomCollectionUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ToListTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ListUndoableActionable;
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 Supplier<ListUndoableActionable<Mapped_>> supplier() {
return ListUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ToMultiMapTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ToSetTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.SetUndoableActionable;
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 Supplier<SetUndoableActionable<Mapped_>> supplier() {
return SetUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ToSimpleMapTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/ToSortedSetComparatorTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.SortedSetUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/tri/UndoableActionableTriCollector.java | package ai.timefold.solver.core.impl.score.stream.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.UndoableActionable;
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 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/AndThenUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public BiFunction<ResultContainer_, A, Runnable> accumulator() {
return delegate.accumulator();
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/AverageIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.impl.score.stream.IntAverageCalculator;
final class AverageIntUniCollector<A> extends IntCalculatorUniCollector<A, Double, IntAverageCalculator> {
AverageIntUniCollector(ToIntFunction<? super A> mapper) {
super(mapper);
}
@Override
public Supplier<IntAverageCalculator> supplier() {
return IntAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/AverageLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Supplier;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.impl.score.stream.LongAverageCalculator;
final class AverageLongUniCollector<A> extends LongCalculatorUniCollector<A, Double, LongAverageCalculator> {
AverageLongUniCollector(ToLongFunction<? super A> mapper) {
super(mapper);
}
@Override
public Supplier<LongAverageCalculator> supplier() {
return LongAverageCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/AverageReferenceUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.ReferenceAverageCalculator;
final class AverageReferenceUniCollector<A, Mapped_, Average_>
extends ObjectCalculatorUniCollector<A, Mapped_, Average_, 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ComposeFourUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 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 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ComposeThreeUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<Triple<ResultHolder1_, ResultHolder2_, ResultHolder3_>> supplier() {
return () -> {
ResultHolder1_ a = firstSupplier.get();
ResultHolder2_ b = secondSupplier.get();
return new Triple<>(a, b, thirdSupplier.get());
};
}
@Override
public 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ComposeTwoUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<Pair<ResultHolder1_, ResultHolder2_>> supplier() {
return () -> new Pair<>(firstSupplier.get(), secondSupplier.get());
}
@Override
public 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ConditionalUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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;
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 Supplier<ResultContainer_> supplier() {
return delegate.supplier();
}
@Override
public BiFunction<ResultContainer_, A, Runnable> accumulator() {
return (resultContainer, a) -> {
if (predicate.test(a)) {
return innerAccumulator.apply(resultContainer, a);
} else {
return ConstantLambdaUtils.noop();
}
};
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ConsecutiveSequencesUniConstraintCollector.java | package ai.timefold.solver.core.impl.score.stream.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.SequenceCalculator;
import ai.timefold.solver.core.impl.util.ConstantLambdaUtils;
final class ConsecutiveSequencesUniConstraintCollector<A>
extends ObjectCalculatorUniCollector<A, A, SequenceChain<A, Integer>, SequenceCalculator<A>> {
private final ToIntFunction<A> indexMap;
public ConsecutiveSequencesUniConstraintCollector(ToIntFunction<A> indexMap) {
super(ConstantLambdaUtils.identity());
this.indexMap = Objects.requireNonNull(indexMap);
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/CountDistinctIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.IntDistinctCountCalculator;
final class CountDistinctIntUniCollector<A, Mapped_>
extends ObjectCalculatorUniCollector<A, Mapped_, Integer, IntDistinctCountCalculator<Mapped_>> {
CountDistinctIntUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<IntDistinctCountCalculator<Mapped_>> supplier() {
return IntDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/CountDistinctLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.LongDistinctCountCalculator;
final class CountDistinctLongUniCollector<A, Mapped_>
extends ObjectCalculatorUniCollector<A, Mapped_, Long, LongDistinctCountCalculator<Mapped_>> {
CountDistinctLongUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<LongDistinctCountCalculator<Mapped_>> supplier() {
return LongDistinctCountCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/CountIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.IntCounter;
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 Supplier<IntCounter> supplier() {
return IntCounter::new;
}
@Override
public BiFunction<IntCounter, A, Runnable> accumulator() {
return (counter, a) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public Function<IntCounter, Integer> finisher() {
return IntCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/CountLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.LongCounter;
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 Supplier<LongCounter> supplier() {
return LongCounter::new;
}
@Override
public BiFunction<LongCounter, A, Runnable> accumulator() {
return (counter, a) -> {
counter.increment();
return counter::decrement;
};
}
@Override
public Function<LongCounter, Long> finisher() {
return LongCounter::result;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/InnerUniConstraintCollectors.java | package ai.timefold.solver.core.impl.score.stream.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.SequenceChain;
import ai.timefold.solver.core.api.score.stream.uni.UniConstraintCollector;
import ai.timefold.solver.core.impl.score.stream.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, Intermediate_, Result_> UniConstraintCollector<A, ?, Result_>
collectAndThen(UniConstraintCollector<A, ?, Intermediate_> delegate,
Function<Intermediate_, Result_> mappingFunction) {
return new AndThenUniCollector<>(delegate, mappingFunction);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/IntCalculatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.IntCalculator;
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 BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final int mapped = mapper.applyAsInt(a);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/LongCalculatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.LongCalculator;
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 BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final long mapped = mapper.applyAsLong(a);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/MaxComparableUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
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 Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::maxCalculator;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/MaxComparatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/MaxPropertyUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/MinComparableUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
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 Supplier<MinMaxUndoableActionable<Result_, Result_>> supplier() {
return MinMaxUndoableActionable::minCalculator;
}
} |
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/MinComparatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/MinPropertyUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.Objects;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.MinMaxUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ObjectCalculatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ObjectCalculator;
abstract sealed class ObjectCalculatorUniCollector<A, Input_, Output_, Calculator_ extends ObjectCalculator<Input_, Output_>>
implements UniConstraintCollector<A, Calculator_, Output_>
permits AverageReferenceUniCollector, 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 BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final Input_ mapped = mapper.apply(a);
calculator.insert(mapped);
return () -> calculator.retract(mapped);
};
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/SumIntUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Supplier;
import java.util.function.ToIntFunction;
import ai.timefold.solver.core.impl.score.stream.IntSumCalculator;
final class SumIntUniCollector<A> extends IntCalculatorUniCollector<A, Integer, IntSumCalculator> {
SumIntUniCollector(ToIntFunction<? super A> mapper) {
super(mapper);
}
@Override
public Supplier<IntSumCalculator> supplier() {
return IntSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/SumLongUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.function.Supplier;
import java.util.function.ToLongFunction;
import ai.timefold.solver.core.impl.score.stream.LongSumCalculator;
final class SumLongUniCollector<A> extends LongCalculatorUniCollector<A, Long, LongSumCalculator> {
SumLongUniCollector(ToLongFunction<? super A> mapper) {
super(mapper);
}
@Override
public Supplier<LongSumCalculator> supplier() {
return LongSumCalculator::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/SumReferenceUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.ReferenceSumCalculator;
final class SumReferenceUniCollector<A, Result_>
extends ObjectCalculatorUniCollector<A, 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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ToCollectionUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.CustomCollectionUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ToListUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.List;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.ListUndoableActionable;
final class ToListUniCollector<A, Mapped_>
extends UndoableActionableUniCollector<A, Mapped_, List<Mapped_>, ListUndoableActionable<Mapped_>> {
ToListUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<ListUndoableActionable<Mapped_>> supplier() {
return ListUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ToMultiMapUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ToSetUniCollector.java | package ai.timefold.solver.core.impl.score.stream.uni;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Supplier;
import ai.timefold.solver.core.impl.score.stream.SetUndoableActionable;
final class ToSetUniCollector<A, Mapped_>
extends UndoableActionableUniCollector<A, Mapped_, Set<Mapped_>, SetUndoableActionable<Mapped_>> {
ToSetUniCollector(Function<? super A, ? extends Mapped_> mapper) {
super(mapper);
}
@Override
public Supplier<SetUndoableActionable<Mapped_>> supplier() {
return SetUndoableActionable::new;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ToSimpleMapUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.MapUndoableActionable;
import ai.timefold.solver.core.impl.util.Pair;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/ToSortedSetComparatorUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.SortedSetUndoableActionable;
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 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-impl/1.8.1/ai/timefold/solver/core/impl/score/stream | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/stream/uni/UndoableActionableUniCollector.java | package ai.timefold.solver.core.impl.score.stream.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.UndoableActionable;
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 BiFunction<Calculator_, A, Runnable> accumulator() {
return (calculator, a) -> {
final Input_ mapped = mapper.apply(a);
return calculator.insert(mapped);
};
}
@Override
public 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-impl/1.8.1/ai/timefold/solver/core/impl/score | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/score/trend/InitializingScoreTrend.java | package ai.timefold.solver.core.impl.score.trend;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.config.score.trend.InitializingScoreTrendLevel;
/**
* Bounds the possible {@link Score}s for a {@link PlanningSolution} as more and more variables are initialized
* (while the already initialized variables don't change).
*
* @see InitializingScoreTrendLevel
*/
public class InitializingScoreTrend {
public static InitializingScoreTrend parseTrend(String initializingScoreTrendString, int levelsSize) {
String[] trendTokens = initializingScoreTrendString.split("/");
boolean tokenIsSingle = trendTokens.length == 1;
if (!tokenIsSingle && trendTokens.length != levelsSize) {
throw new IllegalArgumentException("The initializingScoreTrendString (" + initializingScoreTrendString
+ ") doesn't follow the correct pattern (" + buildTrendPattern(levelsSize) + "):"
+ " the trendTokens length (" + trendTokens.length
+ ") differs from the levelsSize (" + levelsSize + ").");
}
InitializingScoreTrendLevel[] trendLevels = new InitializingScoreTrendLevel[levelsSize];
for (int i = 0; i < levelsSize; i++) {
trendLevels[i] = InitializingScoreTrendLevel.valueOf(trendTokens[tokenIsSingle ? 0 : i]);
}
return new InitializingScoreTrend(trendLevels);
}
public static InitializingScoreTrend buildUniformTrend(InitializingScoreTrendLevel trendLevel, int levelsSize) {
InitializingScoreTrendLevel[] trendLevels = new InitializingScoreTrendLevel[levelsSize];
for (int i = 0; i < levelsSize; i++) {
trendLevels[i] = trendLevel;
}
return new InitializingScoreTrend(trendLevels);
}
protected static String buildTrendPattern(int levelsSize) {
StringBuilder trendPattern = new StringBuilder(levelsSize * 4);
boolean first = true;
for (int i = 0; i < levelsSize; i++) {
if (first) {
first = false;
} else {
trendPattern.append("/");
}
trendPattern.append(InitializingScoreTrendLevel.ANY.name());
}
return trendPattern.toString();
}
// ************************************************************************
// Fields, constructions, getters and setters
// ************************************************************************
private final InitializingScoreTrendLevel[] trendLevels;
public InitializingScoreTrend(InitializingScoreTrendLevel[] trendLevels) {
this.trendLevels = trendLevels;
}
public InitializingScoreTrendLevel[] getTrendLevels() {
return trendLevels;
}
// ************************************************************************
// Complex methods
// ************************************************************************
public int getLevelsSize() {
return trendLevels.length;
}
public boolean isOnlyUp() {
for (InitializingScoreTrendLevel trendLevel : trendLevels) {
if (trendLevel != InitializingScoreTrendLevel.ONLY_UP) {
return false;
}
}
return true;
}
public boolean isOnlyDown() {
for (InitializingScoreTrendLevel trendLevel : trendLevels) {
if (trendLevel != InitializingScoreTrendLevel.ONLY_DOWN) {
return false;
}
}
return true;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/solver/AbstractSolver.java | package ai.timefold.solver.core.impl.solver;
import java.util.Iterator;
import java.util.List;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.solver.Solver;
import ai.timefold.solver.core.api.solver.event.SolverEventListener;
import ai.timefold.solver.core.impl.phase.AbstractPhase;
import ai.timefold.solver.core.impl.phase.Phase;
import ai.timefold.solver.core.impl.phase.event.PhaseLifecycleListener;
import ai.timefold.solver.core.impl.phase.event.PhaseLifecycleSupport;
import ai.timefold.solver.core.impl.phase.scope.AbstractPhaseScope;
import ai.timefold.solver.core.impl.phase.scope.AbstractStepScope;
import ai.timefold.solver.core.impl.solver.event.SolverEventSupport;
import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecaller;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.impl.solver.termination.Termination;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Common code between {@link DefaultSolver} and child solvers.
* <p>
* Do not create a new child {@link Solver} to implement a new heuristic or metaheuristic,
* just use a new {@link Phase} for that.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see Solver
* @see DefaultSolver
*/
public abstract class AbstractSolver<Solution_> implements Solver<Solution_> {
protected final transient Logger logger = LoggerFactory.getLogger(getClass());
private final SolverEventSupport<Solution_> solverEventSupport = new SolverEventSupport<>(this);
private final PhaseLifecycleSupport<Solution_> phaseLifecycleSupport = new PhaseLifecycleSupport<>();
protected final BestSolutionRecaller<Solution_> bestSolutionRecaller;
// Note that the DefaultSolver.basicPlumbingTermination is a component of this termination.
// Called "solverTermination" to clearly distinguish from "phaseTermination" inside AbstractPhase.
protected final Termination<Solution_> solverTermination;
protected final List<Phase<Solution_>> phaseList;
// ************************************************************************
// Constructors and simple getters/setters
// ************************************************************************
public AbstractSolver(BestSolutionRecaller<Solution_> bestSolutionRecaller, Termination<Solution_> solverTermination,
List<Phase<Solution_>> phaseList) {
this.bestSolutionRecaller = bestSolutionRecaller;
this.solverTermination = solverTermination;
bestSolutionRecaller.setSolverEventSupport(solverEventSupport);
this.phaseList = phaseList;
phaseList.forEach(phase -> ((AbstractPhase<Solution_>) phase).setSolver(this));
}
// ************************************************************************
// Lifecycle methods
// ************************************************************************
public void solvingStarted(SolverScope<Solution_> solverScope) {
solverScope.setWorkingSolutionFromBestSolution();
bestSolutionRecaller.solvingStarted(solverScope);
solverTermination.solvingStarted(solverScope);
phaseLifecycleSupport.fireSolvingStarted(solverScope);
for (Phase<Solution_> phase : phaseList) {
phase.solvingStarted(solverScope);
}
}
protected void runPhases(SolverScope<Solution_> solverScope) {
if (!solverScope.getSolutionDescriptor().hasMovableEntities(solverScope.getScoreDirector())) {
logger.info("Skipped all phases ({}): out of {} planning entities, none are movable (non-pinned).",
phaseList.size(), solverScope.getWorkingEntityCount());
return;
}
Iterator<Phase<Solution_>> it = phaseList.iterator();
while (!solverTermination.isSolverTerminated(solverScope) && it.hasNext()) {
Phase<Solution_> phase = it.next();
phase.solve(solverScope);
// If there is a next phase, it starts from the best solution, which might differ from the working solution.
// If there isn't, no need to planning clone the best solution to the working solution.
if (it.hasNext()) {
solverScope.setWorkingSolutionFromBestSolution();
}
}
}
public void solvingEnded(SolverScope<Solution_> solverScope) {
for (Phase<Solution_> phase : phaseList) {
phase.solvingEnded(solverScope);
}
bestSolutionRecaller.solvingEnded(solverScope);
solverTermination.solvingEnded(solverScope);
phaseLifecycleSupport.fireSolvingEnded(solverScope);
}
public void solvingError(SolverScope<Solution_> solverScope, Exception exception) {
phaseLifecycleSupport.fireSolvingError(solverScope, exception);
for (Phase<Solution_> phase : phaseList) {
phase.solvingError(solverScope, exception);
}
}
public void phaseStarted(AbstractPhaseScope<Solution_> phaseScope) {
bestSolutionRecaller.phaseStarted(phaseScope);
phaseLifecycleSupport.firePhaseStarted(phaseScope);
solverTermination.phaseStarted(phaseScope);
// Do not propagate to phases; the active phase does that for itself and they should not propagate further.
}
public void phaseEnded(AbstractPhaseScope<Solution_> phaseScope) {
bestSolutionRecaller.phaseEnded(phaseScope);
phaseLifecycleSupport.firePhaseEnded(phaseScope);
solverTermination.phaseEnded(phaseScope);
// Do not propagate to phases; the active phase does that for itself and they should not propagate further.
}
public void stepStarted(AbstractStepScope<Solution_> stepScope) {
bestSolutionRecaller.stepStarted(stepScope);
phaseLifecycleSupport.fireStepStarted(stepScope);
solverTermination.stepStarted(stepScope);
// Do not propagate to phases; the active phase does that for itself and they should not propagate further.
}
public void stepEnded(AbstractStepScope<Solution_> stepScope) {
bestSolutionRecaller.stepEnded(stepScope);
phaseLifecycleSupport.fireStepEnded(stepScope);
solverTermination.stepEnded(stepScope);
// Do not propagate to phases; the active phase does that for itself and they should not propagate further.
}
// ************************************************************************
// Event listeners
// ************************************************************************
@Override
public void addEventListener(SolverEventListener<Solution_> eventListener) {
solverEventSupport.addEventListener(eventListener);
}
@Override
public void removeEventListener(SolverEventListener<Solution_> eventListener) {
solverEventSupport.removeEventListener(eventListener);
}
/**
* Add a {@link PhaseLifecycleListener} that is notified
* of {@link PhaseLifecycleListener#solvingStarted(SolverScope) solving} events
* and also of the {@link PhaseLifecycleListener#phaseStarted(AbstractPhaseScope) phase}
* and the {@link PhaseLifecycleListener#stepStarted(AbstractStepScope) step} starting/ending events of all phases.
* <p>
* To get notified for only 1 phase, use {@link Phase#addPhaseLifecycleListener(PhaseLifecycleListener)} instead.
*
* @param phaseLifecycleListener never null
*/
public void addPhaseLifecycleListener(PhaseLifecycleListener<Solution_> phaseLifecycleListener) {
phaseLifecycleSupport.addEventListener(phaseLifecycleListener);
}
/**
* @param phaseLifecycleListener never null
* @see #addPhaseLifecycleListener(PhaseLifecycleListener)
*/
public void removePhaseLifecycleListener(PhaseLifecycleListener<Solution_> phaseLifecycleListener) {
phaseLifecycleSupport.removeEventListener(phaseLifecycleListener);
}
// ************************************************************************
// Simple getters and setters
// ************************************************************************
public BestSolutionRecaller<Solution_> getBestSolutionRecaller() {
return bestSolutionRecaller;
}
public List<Phase<Solution_>> getPhaseList() {
return phaseList;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/solver/BestSolutionHolder.java | package ai.timefold.solver.core.impl.solver;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.Collection;
import java.util.List;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.atomic.AtomicReference;
import java.util.concurrent.locks.Lock;
import java.util.concurrent.locks.ReentrantLock;
import java.util.function.BooleanSupplier;
import ai.timefold.solver.core.api.solver.Solver;
import ai.timefold.solver.core.api.solver.change.ProblemChange;
final class BestSolutionHolder<Solution_> {
private final Lock problemChangesLock = new ReentrantLock();
private final AtomicReference<VersionedBestSolution<Solution_>> versionedBestSolutionRef = new AtomicReference<>();
private final SortedMap<BigInteger, List<CompletableFuture<Void>>> problemChangesPerVersion =
new TreeMap<>();
private BigInteger currentVersion = BigInteger.ZERO;
boolean isEmpty() {
return versionedBestSolutionRef.get() == null;
}
/**
* NOT thread-safe.
*
* @return the last best solution together with problem changes the solution contains.
*/
BestSolutionContainingProblemChanges<Solution_> take() {
VersionedBestSolution<Solution_> versionedBestSolution = versionedBestSolutionRef.getAndSet(null);
if (versionedBestSolution == null) {
return null;
}
SortedMap<BigInteger, List<CompletableFuture<Void>>> containedProblemChangesPerVersion =
problemChangesPerVersion.headMap(versionedBestSolution.getVersion().add(BigInteger.ONE));
List<CompletableFuture<Void>> containedProblemChanges = new ArrayList<>();
for (Map.Entry<BigInteger, List<CompletableFuture<Void>>> entry : containedProblemChangesPerVersion.entrySet()) {
containedProblemChanges.addAll(entry.getValue());
problemChangesPerVersion.remove(entry.getKey());
}
return new BestSolutionContainingProblemChanges<>(versionedBestSolution.getBestSolution(),
containedProblemChanges);
}
/**
* Sets the new best solution if all known problem changes have been processed and thus are contained in this
* best solution.
*
* @param bestSolution the new best solution that replaces the previous one if there is any
* @param isEveryProblemChangeProcessed a supplier that tells if all problem changes have been processed
*/
void set(Solution_ bestSolution, BooleanSupplier isEveryProblemChangeProcessed) {
problemChangesLock.lock();
try {
/*
* The new best solution can be accepted only if there are no pending problem changes nor any additional
* changes may come during this operation. Otherwise, a race condition might occur that leads to associating
* problem changes with a solution that was created later, but does not contain them yet.
* As a result, CompletableFutures representing these changes would be completed too early.
*/
if (isEveryProblemChangeProcessed.getAsBoolean()) {
versionedBestSolutionRef.set(new VersionedBestSolution(bestSolution, currentVersion));
currentVersion = currentVersion.add(BigInteger.ONE);
}
} finally {
problemChangesLock.unlock();
}
}
/**
* Adds a new problem change to a solver and registers the problem change to be later retrieved together with
* a relevant best solution by the {@link #take()} method.
*
* @return CompletableFuture that will be completed after the best solution containing this change is passed to
* a user-defined Consumer.
*/
CompletableFuture<Void> addProblemChange(Solver<Solution_> solver, ProblemChange<Solution_> problemChange) {
problemChangesLock.lock();
try {
CompletableFuture<Void> futureProblemChange = new CompletableFuture<>();
problemChangesPerVersion.compute(currentVersion, (version, futureProblemChangeList) -> {
if (futureProblemChangeList == null) {
futureProblemChangeList = new ArrayList<>();
}
futureProblemChangeList.add(futureProblemChange);
return futureProblemChangeList;
});
solver.addProblemChange(problemChange);
return futureProblemChange;
} finally {
problemChangesLock.unlock();
}
}
void cancelPendingChanges() {
problemChangesLock.lock();
try {
problemChangesPerVersion.values()
.stream()
.flatMap(Collection::stream)
.forEach(pendingProblemChange -> pendingProblemChange.cancel(false));
problemChangesPerVersion.clear();
} finally {
problemChangesLock.unlock();
}
}
private static final class VersionedBestSolution<Solution_> {
final Solution_ bestSolution;
final BigInteger version;
public VersionedBestSolution(Solution_ bestSolution, BigInteger version) {
this.bestSolution = bestSolution;
this.version = version;
}
public Solution_ getBestSolution() {
return bestSolution;
}
public BigInteger getVersion() {
return version;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/solver/ConsumerSupport.java | package ai.timefold.solver.core.impl.solver;
import java.util.concurrent.CompletableFuture;
import java.util.concurrent.ExecutorService;
import java.util.concurrent.Executors;
import java.util.concurrent.Semaphore;
import java.util.function.BiConsumer;
import java.util.function.BooleanSupplier;
import java.util.function.Consumer;
final class ConsumerSupport<Solution_, ProblemId_> implements AutoCloseable {
private final ProblemId_ problemId;
private final Consumer<? super Solution_> bestSolutionConsumer;
private final Consumer<? super Solution_> finalBestSolutionConsumer;
private final BiConsumer<? super ProblemId_, ? super Throwable> exceptionHandler;
private final Semaphore activeConsumption = new Semaphore(1);
private final BestSolutionHolder<Solution_> bestSolutionHolder;
private final ExecutorService consumerExecutor = Executors.newSingleThreadExecutor();
public ConsumerSupport(ProblemId_ problemId, Consumer<? super Solution_> bestSolutionConsumer,
Consumer<? super Solution_> finalBestSolutionConsumer,
BiConsumer<? super ProblemId_, ? super Throwable> exceptionHandler,
BestSolutionHolder<Solution_> bestSolutionHolder) {
this.problemId = problemId;
this.bestSolutionConsumer = bestSolutionConsumer;
this.finalBestSolutionConsumer = finalBestSolutionConsumer == null ? finalBestSolution -> {
} : finalBestSolutionConsumer;
this.exceptionHandler = exceptionHandler;
this.bestSolutionHolder = bestSolutionHolder;
}
// Called on the Solver thread.
void consumeIntermediateBestSolution(Solution_ bestSolution, BooleanSupplier isEveryProblemChangeProcessed) {
/*
* If the bestSolutionConsumer is not provided, the best solution is still set for the purpose of recording
* problem changes.
*/
bestSolutionHolder.set(bestSolution, isEveryProblemChangeProcessed);
if (bestSolutionConsumer != null) {
tryConsumeWaitingIntermediateBestSolution();
}
}
// Called on the Solver thread after Solver#solve() returns.
void consumeFinalBestSolution(Solution_ finalBestSolution) {
try {
// Wait for the previous consumption to complete.
// As the solver has already finished, holding the solver thread is not an issue.
activeConsumption.acquire();
} catch (InterruptedException e) {
Thread.currentThread().interrupt();
throw new IllegalStateException("Interrupted when waiting for the final best solution consumption.");
}
// Make sure the final best solution is consumed by the intermediate best solution consumer first.
// Situation:
// The consumer is consuming the last but one best solution. The final best solution is waiting for the consumer.
if (bestSolutionConsumer != null) {
scheduleIntermediateBestSolutionConsumption();
}
consumerExecutor.submit(() -> {
try {
finalBestSolutionConsumer.accept(finalBestSolution);
} catch (Throwable throwable) {
exceptionHandler.accept(problemId, throwable);
} finally {
// If there is no intermediate best solution consumer, complete the problem changes now.
if (bestSolutionConsumer == null) {
bestSolutionHolder.take().completeProblemChanges();
}
// Cancel problem changes that arrived after the solver terminated.
bestSolutionHolder.cancelPendingChanges();
activeConsumption.release();
disposeConsumerThread();
}
});
}
// Called both on the Solver thread and the Consumer thread.
private void tryConsumeWaitingIntermediateBestSolution() {
if (bestSolutionHolder.isEmpty()) {
return; // There is no best solution to consume.
}
if (activeConsumption.tryAcquire()) {
scheduleIntermediateBestSolutionConsumption().thenRunAsync(this::tryConsumeWaitingIntermediateBestSolution,
consumerExecutor);
}
}
/**
* Called both on the Solver thread and the Consumer thread.
* Don't call without locking, otherwise multiple consumptions may be scheduled.
*/
private CompletableFuture<Void> scheduleIntermediateBestSolutionConsumption() {
return CompletableFuture.runAsync(() -> {
BestSolutionContainingProblemChanges<Solution_> bestSolutionContainingProblemChanges = bestSolutionHolder.take();
if (bestSolutionContainingProblemChanges != null) {
try {
bestSolutionConsumer.accept(bestSolutionContainingProblemChanges.getBestSolution());
bestSolutionContainingProblemChanges.completeProblemChanges();
} catch (Throwable throwable) {
if (exceptionHandler != null) {
exceptionHandler.accept(problemId, throwable);
}
bestSolutionContainingProblemChanges.completeProblemChangesExceptionally(throwable);
} finally {
activeConsumption.release();
}
}
}, consumerExecutor);
}
@Override
public void close() {
disposeConsumerThread();
bestSolutionHolder.cancelPendingChanges();
}
private void disposeConsumerThread() {
consumerExecutor.shutdownNow();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/solver/DefaultRecommendedFit.java | package ai.timefold.solver.core.impl.solver;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.analysis.ScoreAnalysis;
import ai.timefold.solver.core.api.solver.RecommendedFit;
public record DefaultRecommendedFit<Proposition_, Score_ extends Score<Score_>>(long index, Proposition_ proposition,
ScoreAnalysis<Score_> scoreAnalysisDiff)
implements
RecommendedFit<Proposition_, Score_>,
Comparable<DefaultRecommendedFit<Proposition_, Score_>> {
@Override
public int compareTo(DefaultRecommendedFit<Proposition_, Score_> other) {
int scoreComparison = scoreAnalysisDiff.score().compareTo(other.scoreAnalysisDiff.score());
if (scoreComparison != 0) {
return -scoreComparison; // Better scores first.
}
// Otherwise maintain insertion order.
return Long.compareUnsigned(index, other.index); // Unsigned == many more positive values.
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/solver/DefaultSolutionManager.java | package ai.timefold.solver.core.impl.solver;
import java.util.List;
import java.util.Objects;
import java.util.function.Function;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.ScoreExplanation;
import ai.timefold.solver.core.api.score.analysis.ScoreAnalysis;
import ai.timefold.solver.core.api.solver.RecommendedFit;
import ai.timefold.solver.core.api.solver.ScoreAnalysisFetchPolicy;
import ai.timefold.solver.core.api.solver.SolutionManager;
import ai.timefold.solver.core.api.solver.SolutionUpdatePolicy;
import ai.timefold.solver.core.api.solver.SolverFactory;
import ai.timefold.solver.core.api.solver.SolverManager;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.impl.score.DefaultScoreExplanation;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirectorFactory;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public final class DefaultSolutionManager<Solution_, Score_ extends Score<Score_>>
implements SolutionManager<Solution_, Score_> {
private final DefaultSolverFactory<Solution_> solverFactory;
private final InnerScoreDirectorFactory<Solution_, Score_> scoreDirectorFactory;
public <ProblemId_> DefaultSolutionManager(SolverManager<Solution_, ProblemId_> solverManager) {
this(((DefaultSolverManager<Solution_, ProblemId_>) solverManager).getSolverFactory());
}
public DefaultSolutionManager(SolverFactory<Solution_> solverFactory) {
this.solverFactory = ((DefaultSolverFactory<Solution_>) solverFactory);
this.scoreDirectorFactory = this.solverFactory.getScoreDirectorFactory();
}
public InnerScoreDirectorFactory<Solution_, Score_> getScoreDirectorFactory() {
return scoreDirectorFactory;
}
@Override
public Score_ update(Solution_ solution, SolutionUpdatePolicy solutionUpdatePolicy) {
if (solutionUpdatePolicy == SolutionUpdatePolicy.NO_UPDATE) {
throw new IllegalArgumentException("Can not call " + this.getClass().getSimpleName()
+ ".update() with this solutionUpdatePolicy (" + solutionUpdatePolicy + ").");
}
return callScoreDirector(solution, solutionUpdatePolicy,
s -> (Score_) s.getSolutionDescriptor().getScore(s.getWorkingSolution()), false, false);
}
private <Result_> Result_ callScoreDirector(Solution_ solution,
SolutionUpdatePolicy solutionUpdatePolicy, Function<InnerScoreDirector<Solution_, Score_>, Result_> function,
boolean enableConstraintMatch, boolean cloneSolution) {
var isShadowVariableUpdateEnabled = solutionUpdatePolicy.isShadowVariableUpdateEnabled();
var nonNullSolution = Objects.requireNonNull(solution);
try (var scoreDirector = getScoreDirectorFactory().buildScoreDirector(cloneSolution, enableConstraintMatch,
!isShadowVariableUpdateEnabled)) {
nonNullSolution = cloneSolution ? scoreDirector.cloneSolution(nonNullSolution) : nonNullSolution;
scoreDirector.setWorkingSolution(nonNullSolution);
if (enableConstraintMatch && !scoreDirector.isConstraintMatchEnabled()) {
throw new IllegalStateException("""
Requested constraint matching but score director doesn't support it.
Maybe use Constraint Streams instead of Easy or Incremental score calculator?""");
}
if (isShadowVariableUpdateEnabled) {
scoreDirector.forceTriggerVariableListeners();
}
if (solutionUpdatePolicy.isScoreUpdateEnabled()) {
scoreDirector.calculateScore();
}
return function.apply(scoreDirector);
}
}
@Override
public ScoreExplanation<Solution_, Score_> explain(Solution_ solution, SolutionUpdatePolicy solutionUpdatePolicy) {
var currentScore = (Score_) scoreDirectorFactory.getSolutionDescriptor().getScore(solution);
var explanation = callScoreDirector(solution, solutionUpdatePolicy, DefaultScoreExplanation::new, true, false);
assertFreshScore(solution, currentScore, explanation.getScore(), solutionUpdatePolicy);
return explanation;
}
private void assertFreshScore(Solution_ solution, Score_ currentScore, Score_ calculatedScore,
SolutionUpdatePolicy solutionUpdatePolicy) {
if (!solutionUpdatePolicy.isScoreUpdateEnabled() && currentScore != null) {
// Score update is not enabled and score is not null; this means the score is supposed to be valid.
// Yet it is different from a freshly calculated score, suggesting previous score corruption.
if (!calculatedScore.equals(currentScore)) {
throw new IllegalStateException("""
Current score (%s) and freshly calculated score (%s) for solution (%s) do not match.
Maybe run %s environment mode to check for score corruptions.
Otherwise enable %s.%s to update the stale score.
"""
.formatted(currentScore, calculatedScore, solution, EnvironmentMode.TRACKED_FULL_ASSERT,
SolutionUpdatePolicy.class.getSimpleName(),
SolutionUpdatePolicy.UPDATE_ALL));
}
}
}
@Override
public ScoreAnalysis<Score_> analyze(Solution_ solution, ScoreAnalysisFetchPolicy fetchPolicy,
SolutionUpdatePolicy solutionUpdatePolicy) {
Objects.requireNonNull(fetchPolicy, "fetchPolicy");
var currentScore = (Score_) scoreDirectorFactory.getSolutionDescriptor().getScore(solution);
var analysis = callScoreDirector(solution, solutionUpdatePolicy,
scoreDirector -> scoreDirector.buildScoreAnalysis(fetchPolicy == ScoreAnalysisFetchPolicy.FETCH_ALL), true,
false);
assertFreshScore(solution, currentScore, analysis.score(), solutionUpdatePolicy);
return analysis;
}
@Override
public <In_, Out_> List<RecommendedFit<Out_, Score_>> recommendFit(Solution_ solution, In_ fittedEntityOrElement,
Function<In_, Out_> propositionFunction, ScoreAnalysisFetchPolicy fetchPolicy) {
var fitter = new Fitter<Solution_, In_, Out_, Score_>(solverFactory, solution, fittedEntityOrElement,
propositionFunction, fetchPolicy);
return callScoreDirector(solution, SolutionUpdatePolicy.UPDATE_ALL, fitter, true, true);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/solver/DefaultSolver.java | package ai.timefold.solver.core.impl.solver;
import java.util.Collections;
import java.util.List;
import java.util.Map;
import java.util.Objects;
import java.util.concurrent.BlockingQueue;
import java.util.concurrent.atomic.AtomicBoolean;
import java.util.stream.Collectors;
import ai.timefold.solver.core.api.domain.lookup.PlanningId;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.solver.ProblemFactChange;
import ai.timefold.solver.core.api.solver.Solver;
import ai.timefold.solver.core.api.solver.change.ProblemChange;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.config.solver.monitoring.SolverMetric;
import ai.timefold.solver.core.impl.domain.common.accessor.MemberAccessor;
import ai.timefold.solver.core.impl.phase.Phase;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirector;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirectorFactory;
import ai.timefold.solver.core.impl.solver.change.ProblemChangeAdapter;
import ai.timefold.solver.core.impl.solver.random.RandomFactory;
import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecaller;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.impl.solver.termination.BasicPlumbingTermination;
import ai.timefold.solver.core.impl.solver.termination.Termination;
import io.micrometer.core.instrument.Counter;
import io.micrometer.core.instrument.LongTaskTimer;
import io.micrometer.core.instrument.Metrics;
import io.micrometer.core.instrument.Tags;
/**
* Default implementation for {@link Solver}.
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see Solver
* @see AbstractSolver
*/
public class DefaultSolver<Solution_> extends AbstractSolver<Solution_> {
protected EnvironmentMode environmentMode;
protected RandomFactory randomFactory;
protected BasicPlumbingTermination<Solution_> basicPlumbingTermination;
protected final AtomicBoolean solving = new AtomicBoolean(false);
protected final SolverScope<Solution_> solverScope;
private final String moveThreadCountDescription;
// ************************************************************************
// Constructors and simple getters/setters
// ************************************************************************
public DefaultSolver(EnvironmentMode environmentMode, RandomFactory randomFactory,
BestSolutionRecaller<Solution_> bestSolutionRecaller,
BasicPlumbingTermination<Solution_> basicPlumbingTermination, Termination<Solution_> termination,
List<Phase<Solution_>> phaseList, SolverScope<Solution_> solverScope, String moveThreadCountDescription) {
super(bestSolutionRecaller, termination, phaseList);
this.environmentMode = environmentMode;
this.randomFactory = randomFactory;
this.basicPlumbingTermination = basicPlumbingTermination;
this.solverScope = solverScope;
this.moveThreadCountDescription = moveThreadCountDescription;
}
public EnvironmentMode getEnvironmentMode() {
return environmentMode;
}
public RandomFactory getRandomFactory() {
return randomFactory;
}
public InnerScoreDirectorFactory<Solution_, ?> getScoreDirectorFactory() {
return solverScope.getScoreDirector().getScoreDirectorFactory();
}
public SolverScope<Solution_> getSolverScope() {
return solverScope;
}
// ************************************************************************
// Complex getters
// ************************************************************************
public long getTimeMillisSpent() {
Long startingSystemTimeMillis = solverScope.getStartingSystemTimeMillis();
if (startingSystemTimeMillis == null) {
// The solver hasn't started yet
return 0L;
}
Long endingSystemTimeMillis = solverScope.getEndingSystemTimeMillis();
if (endingSystemTimeMillis == null) {
// The solver hasn't ended yet
endingSystemTimeMillis = System.currentTimeMillis();
}
return endingSystemTimeMillis - startingSystemTimeMillis;
}
public long getScoreCalculationCount() {
return solverScope.getScoreCalculationCount();
}
public long getScoreCalculationSpeed() {
return SolverScope.getScoreCalculationSpeed(getScoreCalculationCount(), getTimeMillisSpent());
}
@Override
public boolean isSolving() {
return solving.get();
}
@Override
public boolean terminateEarly() {
boolean terminationEarlySuccessful = basicPlumbingTermination.terminateEarly();
if (terminationEarlySuccessful) {
logger.info("Terminating solver early.");
}
return terminationEarlySuccessful;
}
@Override
public boolean isTerminateEarly() {
return basicPlumbingTermination.isTerminateEarly();
}
@Override
public boolean addProblemFactChange(ProblemFactChange<Solution_> problemFactChange) {
return basicPlumbingTermination.addProblemChange(ProblemChangeAdapter.create(problemFactChange));
}
@Override
public boolean addProblemFactChanges(List<ProblemFactChange<Solution_>> problemFactChangeList) {
Objects.requireNonNull(problemFactChangeList,
() -> "The list of problem fact changes (" + problemFactChangeList + ") cannot be null.");
List<ProblemChangeAdapter<Solution_>> problemChangeAdapterList = problemFactChangeList.stream()
.map(ProblemChangeAdapter::create)
.collect(Collectors.toList());
return basicPlumbingTermination.addProblemChanges(problemChangeAdapterList);
}
@Override
public void addProblemChange(ProblemChange<Solution_> problemChange) {
basicPlumbingTermination.addProblemChange(ProblemChangeAdapter.create(problemChange));
}
@Override
public void addProblemChanges(List<ProblemChange<Solution_>> problemChangeList) {
Objects.requireNonNull(problemChangeList,
() -> "The list of problem changes (" + problemChangeList + ") cannot be null.");
problemChangeList.forEach(this::addProblemChange);
}
@Override
public boolean isEveryProblemChangeProcessed() {
return basicPlumbingTermination.isEveryProblemFactChangeProcessed();
}
@Override
public boolean isEveryProblemFactChangeProcessed() {
return basicPlumbingTermination.isEveryProblemFactChangeProcessed();
}
public void setMonitorTagMap(Map<String, String> monitorTagMap) {
Tags monitoringTags = Objects.requireNonNullElse(monitorTagMap, Collections.<String, String> emptyMap())
.entrySet().stream().map(entry -> Tags.of(entry.getKey(), entry.getValue()))
.reduce(Tags.empty(), Tags::and);
solverScope.setMonitoringTags(monitoringTags);
}
// ************************************************************************
// Worker methods
// ************************************************************************
@Override
public final Solution_ solve(Solution_ problem) {
if (problem == null) {
throw new IllegalArgumentException("The problem (" + problem + ") must not be null.");
}
// No tags for these metrics; they are global
LongTaskTimer solveLengthTimer = Metrics.more().longTaskTimer(SolverMetric.SOLVE_DURATION.getMeterId());
Counter errorCounter = Metrics.counter(SolverMetric.ERROR_COUNT.getMeterId());
solverScope.setBestSolution(problem);
outerSolvingStarted(solverScope);
boolean restartSolver = true;
while (restartSolver) {
LongTaskTimer.Sample sample = solveLengthTimer.start();
try {
// solvingStarted will call registerSolverSpecificMetrics(), since
// the solverScope need to be fully initialized to calculate the
// problem's scale metrics
solvingStarted(solverScope);
runPhases(solverScope);
solvingEnded(solverScope);
} catch (Exception e) {
errorCounter.increment();
solvingError(solverScope, e);
throw e;
} finally {
sample.stop();
unregisterSolverSpecificMetrics();
}
restartSolver = checkProblemFactChanges();
}
outerSolvingEnded(solverScope);
return solverScope.getBestSolution();
}
public void outerSolvingStarted(SolverScope<Solution_> solverScope) {
solving.set(true);
basicPlumbingTermination.resetTerminateEarly();
solverScope.setStartingSolverCount(0);
solverScope.setWorkingRandom(randomFactory.createRandom());
}
@Override
public void solvingStarted(SolverScope<Solution_> solverScope) {
assertCorrectSolutionState();
solverScope.startingNow();
solverScope.getScoreDirector().resetCalculationCount();
super.solvingStarted(solverScope);
var startingSolverCount = solverScope.getStartingSolverCount() + 1;
solverScope.setStartingSolverCount(startingSolverCount);
registerSolverSpecificMetrics();
logger.info("Solving {}: time spent ({}), best score ({}), "
+ "environment mode ({}), move thread count ({}), random ({}).",
(startingSolverCount == 1 ? "started" : "restarted"),
solverScope.calculateTimeMillisSpentUpToNow(),
solverScope.getBestScore(),
environmentMode.name(),
moveThreadCountDescription,
(randomFactory != null ? randomFactory : "not fixed"));
if (logger.isInfoEnabled()) { // Formatting is expensive here.
var problemSizeStatistics = solverScope.getProblemSizeStatistics();
logger.info(
"Problem scale: entity count ({}), variable count ({}), approximate value count ({}), approximate problem scale ({}).",
problemSizeStatistics.entityCount(), problemSizeStatistics.variableCount(),
problemSizeStatistics.approximateValueCount(),
problemSizeStatistics.approximateProblemScaleAsFormattedString());
}
}
private void registerSolverSpecificMetrics() {
solverScope.setProblemSizeStatistics(
solverScope.getSolutionDescriptor().getProblemSizeStatistics(solverScope.getScoreDirector(),
solverScope.getWorkingSolution()));
solverScope.getSolverMetricSet().forEach(solverMetric -> solverMetric.register(this));
}
private void unregisterSolverSpecificMetrics() {
solverScope.getSolverMetricSet().forEach(solverMetric -> solverMetric.unregister(this));
}
private void assertCorrectSolutionState() {
solverScope.getSolutionDescriptor().visitAllProblemFacts(solverScope.getBestSolution(), this::assertNonNullPlanningId);
solverScope.getSolutionDescriptor().visitAllEntities(solverScope.getBestSolution(), entity -> {
assertNonNullPlanningId(entity);
// Ensure correct state of pinning properties.
var entityDescriptor = solverScope.getSolutionDescriptor().findEntityDescriptorOrFail(entity.getClass());
if (!entityDescriptor.supportsPinning() || !entityDescriptor.hasAnyGenuineListVariables()) {
return;
}
var listVariableDescriptor = entityDescriptor.getGenuineListVariableDescriptor();
int pinIndex = listVariableDescriptor.getFirstUnpinnedIndex(entity);
if (entityDescriptor.isMovable(solverScope.getScoreDirector(), entity)) {
if (pinIndex < 0) {
throw new IllegalStateException("The movable planning entity (%s) has a pin index (%s) which is negative."
.formatted(entity, pinIndex));
}
var listSize = listVariableDescriptor.getListSize(entity);
if (pinIndex > listSize) {
// pinIndex == listSize is allowed, as that says the pin is at the end of the list,
// allowing additions to the list.
throw new IllegalStateException(
"The movable planning entity (%s) has a pin index (%s) which is greater than the list size (%s)."
.formatted(entity, pinIndex, listSize));
}
} else {
if (pinIndex != 0) {
throw new IllegalStateException("The immovable planning entity (%s) has a pin index (%s) which is not 0."
.formatted(entity, pinIndex));
}
}
});
}
private void assertNonNullPlanningId(Object fact) {
Class<?> factClass = fact.getClass();
MemberAccessor planningIdAccessor = solverScope.getSolutionDescriptor().getPlanningIdAccessor(factClass);
if (planningIdAccessor == null) { // There is no planning ID annotation.
return;
}
Object id = planningIdAccessor.executeGetter(fact);
if (id == null) { // Fail fast as planning ID is null.
throw new IllegalStateException("The planningId (" + id + ") of the member (" + planningIdAccessor
+ ") of the class (" + factClass + ") on object (" + fact + ") must not be null.\n"
+ "Maybe initialize the planningId of the class (" + planningIdAccessor.getDeclaringClass()
+ ") instance (" + fact + ") before solving.\n" +
"Maybe remove the @" + PlanningId.class.getSimpleName() + " annotation.");
}
}
@Override
public void solvingEnded(SolverScope<Solution_> solverScope) {
super.solvingEnded(solverScope);
solverScope.endingNow();
}
public void outerSolvingEnded(SolverScope<Solution_> solverScope) {
logger.info("Solving ended: time spent ({}), best score ({}), score calculation speed ({}/sec), "
+ "phase total ({}), environment mode ({}), move thread count ({}).",
solverScope.getTimeMillisSpent(),
solverScope.getBestScore(),
solverScope.getScoreCalculationSpeed(),
phaseList.size(),
environmentMode.name(),
moveThreadCountDescription);
// Must be kept open for doProblemFactChange
solverScope.getScoreDirector().close();
solving.set(false);
}
private boolean checkProblemFactChanges() {
boolean restartSolver = basicPlumbingTermination.waitForRestartSolverDecision();
if (!restartSolver) {
return false;
} else {
BlockingQueue<ProblemChangeAdapter<Solution_>> problemFactChangeQueue = basicPlumbingTermination
.startProblemFactChangesProcessing();
solverScope.setWorkingSolutionFromBestSolution();
int stepIndex = 0;
ProblemChangeAdapter<Solution_> problemChangeAdapter = problemFactChangeQueue.poll();
while (problemChangeAdapter != null) {
problemChangeAdapter.doProblemChange(solverScope);
logger.debug(" Real-time problem change applied; step index ({}).", stepIndex);
stepIndex++;
problemChangeAdapter = problemFactChangeQueue.poll();
}
// All PFCs are processed, fail fast if any of the new facts have null planning IDs.
InnerScoreDirector<Solution_, ?> scoreDirector = solverScope.getScoreDirector();
assertCorrectSolutionState();
// Everything is fine, proceed.
Score<?> score = scoreDirector.calculateScore();
basicPlumbingTermination.endProblemFactChangesProcessing();
bestSolutionRecaller.updateBestSolutionAndFireIfInitialized(solverScope);
logger.info("Real-time problem fact changes done: step total ({}), new best score ({}).",
stepIndex, score);
return true;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl | java-sources/ai/timefold/solver/timefold-solver-core-impl/1.8.1/ai/timefold/solver/core/impl/solver/DefaultSolverFactory.java | package ai.timefold.solver.core.impl.solver;
import java.util.ArrayList;
import java.util.Collections;
import java.util.EnumSet;
import java.util.List;
import java.util.Objects;
import java.util.OptionalInt;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.solver.Solver;
import ai.timefold.solver.core.api.solver.SolverConfigOverride;
import ai.timefold.solver.core.api.solver.SolverFactory;
import ai.timefold.solver.core.config.constructionheuristic.ConstructionHeuristicPhaseConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.EntityPlacerConfig;
import ai.timefold.solver.core.config.constructionheuristic.placer.QueuedEntityPlacerConfig;
import ai.timefold.solver.core.config.localsearch.LocalSearchPhaseConfig;
import ai.timefold.solver.core.config.score.director.ScoreDirectorFactoryConfig;
import ai.timefold.solver.core.config.solver.EnvironmentMode;
import ai.timefold.solver.core.config.solver.SolverConfig;
import ai.timefold.solver.core.config.solver.monitoring.SolverMetric;
import ai.timefold.solver.core.config.solver.random.RandomType;
import ai.timefold.solver.core.config.solver.termination.TerminationConfig;
import ai.timefold.solver.core.config.util.ConfigUtils;
import ai.timefold.solver.core.impl.AbstractFromConfigFactory;
import ai.timefold.solver.core.impl.constructionheuristic.DefaultConstructionHeuristicPhaseFactory;
import ai.timefold.solver.core.impl.domain.solution.descriptor.SolutionDescriptor;
import ai.timefold.solver.core.impl.domain.variable.descriptor.ListVariableDescriptor;
import ai.timefold.solver.core.impl.heuristic.HeuristicConfigPolicy;
import ai.timefold.solver.core.impl.phase.Phase;
import ai.timefold.solver.core.impl.phase.PhaseFactory;
import ai.timefold.solver.core.impl.score.director.InnerScoreDirectorFactory;
import ai.timefold.solver.core.impl.score.director.ScoreDirectorFactoryFactory;
import ai.timefold.solver.core.impl.solver.change.DefaultProblemChangeDirector;
import ai.timefold.solver.core.impl.solver.random.DefaultRandomFactory;
import ai.timefold.solver.core.impl.solver.random.RandomFactory;
import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecaller;
import ai.timefold.solver.core.impl.solver.recaller.BestSolutionRecallerFactory;
import ai.timefold.solver.core.impl.solver.scope.SolverScope;
import ai.timefold.solver.core.impl.solver.termination.BasicPlumbingTermination;
import ai.timefold.solver.core.impl.solver.termination.Termination;
import ai.timefold.solver.core.impl.solver.termination.TerminationFactory;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
import io.micrometer.core.instrument.Tags;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
* @see SolverFactory
*/
public final class DefaultSolverFactory<Solution_> implements SolverFactory<Solution_> {
private static final Logger LOGGER = LoggerFactory.getLogger(DefaultSolverFactory.class);
private static final long DEFAULT_RANDOM_SEED = 0L;
private final SolverConfig solverConfig;
private final SolutionDescriptor<Solution_> solutionDescriptor;
private final InnerScoreDirectorFactory<Solution_, ?> scoreDirectorFactory;
public DefaultSolverFactory(SolverConfig solverConfig) {
this.solverConfig = Objects.requireNonNull(solverConfig, "The solverConfig (" + solverConfig + ") cannot be null.");
this.solutionDescriptor = buildSolutionDescriptor();
// Caching score director factory as it potentially does expensive things.
this.scoreDirectorFactory = buildScoreDirectorFactory();
}
public SolutionDescriptor<Solution_> getSolutionDescriptor() {
return solutionDescriptor;
}
public <Score_ extends Score<Score_>> InnerScoreDirectorFactory<Solution_, Score_> getScoreDirectorFactory() {
return (InnerScoreDirectorFactory<Solution_, Score_>) scoreDirectorFactory;
}
@Override
public Solver<Solution_> buildSolver(SolverConfigOverride<Solution_> configOverride) {
Objects.requireNonNull(configOverride, "Invalid configOverride (null) given to SolverFactory.");
var isDaemon = Objects.requireNonNullElse(solverConfig.getDaemon(), false);
var solverScope = new SolverScope<Solution_>();
var monitoringConfig = solverConfig.determineMetricConfig();
solverScope.setMonitoringTags(Tags.empty());
var metricsRequiringConstraintMatchSet = Collections.<SolverMetric> emptyList();
if (!monitoringConfig.getSolverMetricList().isEmpty()) {
solverScope.setSolverMetricSet(EnumSet.copyOf(monitoringConfig.getSolverMetricList()));
metricsRequiringConstraintMatchSet = solverScope.getSolverMetricSet().stream()
.filter(SolverMetric::isMetricConstraintMatchBased)
.filter(solverScope::isMetricEnabled)
.toList();
} else {
solverScope.setSolverMetricSet(EnumSet.noneOf(SolverMetric.class));
}
var environmentMode = solverConfig.determineEnvironmentMode();
var constraintMatchEnabled = !metricsRequiringConstraintMatchSet.isEmpty() || environmentMode.isAsserted();
if (constraintMatchEnabled && !environmentMode.isAsserted()) {
LOGGER.info(
"Enabling constraint matching as required by the enabled metrics ({}). This will impact solver performance.",
metricsRequiringConstraintMatchSet);
}
var innerScoreDirector = scoreDirectorFactory.buildScoreDirector(true, constraintMatchEnabled);
solverScope.setScoreDirector(innerScoreDirector);
solverScope.setProblemChangeDirector(new DefaultProblemChangeDirector<>(innerScoreDirector));
var moveThreadCount = resolveMoveThreadCount(true);
var bestSolutionRecaller = BestSolutionRecallerFactory.create().<Solution_> buildBestSolutionRecaller(environmentMode);
var randomFactory = buildRandomFactory(environmentMode);
var configPolicy = new HeuristicConfigPolicy.Builder<>(
environmentMode,
moveThreadCount,
solverConfig.getMoveThreadBufferSize(),
solverConfig.getThreadFactoryClass(),
solverConfig.getNearbyDistanceMeterClass(),
randomFactory.createRandom(),
scoreDirectorFactory.getInitializingScoreTrend(),
solutionDescriptor,
ClassInstanceCache.create()).build();
var basicPlumbingTermination = new BasicPlumbingTermination<Solution_>(isDaemon);
var termination = buildTerminationConfig(basicPlumbingTermination, configPolicy, configOverride);
var phaseList = buildPhaseList(configPolicy, bestSolutionRecaller, termination);
return new DefaultSolver<>(environmentMode, randomFactory, bestSolutionRecaller, basicPlumbingTermination,
termination, phaseList, solverScope,
moveThreadCount == null ? SolverConfig.MOVE_THREAD_COUNT_NONE : Integer.toString(moveThreadCount));
}
public Integer resolveMoveThreadCount(boolean enforceMaximum) {
var maybeCount =
new MoveThreadCountResolver().resolveMoveThreadCount(solverConfig.getMoveThreadCount(), enforceMaximum);
if (maybeCount.isPresent()) {
return maybeCount.getAsInt();
} else {
return null;
}
}
private Termination<Solution_> buildTerminationConfig(BasicPlumbingTermination<Solution_> basicPlumbingTermination,
HeuristicConfigPolicy<Solution_> configPolicy,
SolverConfigOverride<Solution_> solverConfigOverride) {
var terminationConfig = Objects.requireNonNullElseGet(solverConfig.getTerminationConfig(), TerminationConfig::new);
if (solverConfigOverride.getTerminationConfig() != null) {
terminationConfig = solverConfigOverride.getTerminationConfig();
}
return TerminationFactory.<Solution_> create(terminationConfig)
.buildTermination(configPolicy, basicPlumbingTermination);
}
private SolutionDescriptor<Solution_> buildSolutionDescriptor() {
if (solverConfig.getSolutionClass() == null) {
throw new IllegalArgumentException("The solver configuration must have a solutionClass (" +
solverConfig.getSolutionClass() +
"). If you're using the Quarkus extension or Spring Boot starter, it should have been filled in " +
"already.");
}
if (ConfigUtils.isEmptyCollection(solverConfig.getEntityClassList())) {
throw new IllegalArgumentException("The solver configuration must have at least 1 entityClass (" +
solverConfig.getEntityClassList() + "). If you're using the Quarkus extension or Spring Boot starter, " +
"it should have been filled in already.");
}
SolutionDescriptor<Solution_> solutionDescriptor =
SolutionDescriptor.buildSolutionDescriptor(solverConfig.determineDomainAccessType(),
(Class<Solution_>) solverConfig.getSolutionClass(),
solverConfig.getGizmoMemberAccessorMap(),
solverConfig.getGizmoSolutionClonerMap(),
solverConfig.getEntityClassList());
EnvironmentMode environmentMode = solverConfig.determineEnvironmentMode();
if (environmentMode.isAsserted()) {
solutionDescriptor.setAssertModelForCloning(true);
}
return solutionDescriptor;
}
private InnerScoreDirectorFactory<Solution_, ?> buildScoreDirectorFactory() {
EnvironmentMode environmentMode = solverConfig.determineEnvironmentMode();
ScoreDirectorFactoryConfig scoreDirectorFactoryConfig_ =
Objects.requireNonNullElseGet(solverConfig.getScoreDirectorFactoryConfig(),
ScoreDirectorFactoryConfig::new);
ScoreDirectorFactoryFactory<Solution_, ?> scoreDirectorFactoryFactory =
new ScoreDirectorFactoryFactory<>(scoreDirectorFactoryConfig_);
return scoreDirectorFactoryFactory.buildScoreDirectorFactory(solverConfig.getClassLoader(), environmentMode,
solutionDescriptor);
}
public RandomFactory buildRandomFactory(EnvironmentMode environmentMode_) {
RandomFactory randomFactory;
if (solverConfig.getRandomFactoryClass() != null) {
if (solverConfig.getRandomType() != null || solverConfig.getRandomSeed() != null) {
throw new IllegalArgumentException(
"The solverConfig with randomFactoryClass (" + solverConfig.getRandomFactoryClass()
+ ") has a non-null randomType (" + solverConfig.getRandomType()
+ ") or a non-null randomSeed (" + solverConfig.getRandomSeed() + ").");
}
randomFactory = ConfigUtils.newInstance(solverConfig, "randomFactoryClass", solverConfig.getRandomFactoryClass());
} else {
RandomType randomType_ = Objects.requireNonNullElse(solverConfig.getRandomType(), RandomType.JDK);
Long randomSeed_ = solverConfig.getRandomSeed();
if (solverConfig.getRandomSeed() == null && environmentMode_ != EnvironmentMode.NON_REPRODUCIBLE) {
randomSeed_ = DEFAULT_RANDOM_SEED;
}
randomFactory = new DefaultRandomFactory(randomType_, randomSeed_);
}
return randomFactory;
}
public List<Phase<Solution_>> buildPhaseList(HeuristicConfigPolicy<Solution_> configPolicy,
BestSolutionRecaller<Solution_> bestSolutionRecaller, Termination<Solution_> termination) {
var phaseConfigList = solverConfig.getPhaseConfigList();
if (ConfigUtils.isEmptyCollection(phaseConfigList)) {
var genuineEntityDescriptorCollection = configPolicy.getSolutionDescriptor().getGenuineEntityDescriptors();
var listVariableDescriptor = configPolicy.getSolutionDescriptor().getListVariableDescriptor();
var entityClassToListVariableDescriptorListMap =
listVariableDescriptor == null ? Collections.<Class<?>, List<ListVariableDescriptor<Solution_>>> emptyMap()
: Collections.singletonMap(listVariableDescriptor.getEntityDescriptor().getEntityClass(),
List.of(listVariableDescriptor));
phaseConfigList = new ArrayList<>(genuineEntityDescriptorCollection.size() + 1);
for (var genuineEntityDescriptor : genuineEntityDescriptorCollection) {
var constructionHeuristicPhaseConfig = new ConstructionHeuristicPhaseConfig();
EntityPlacerConfig<?> entityPlacerConfig;
if (entityClassToListVariableDescriptorListMap.containsKey(genuineEntityDescriptor.getEntityClass())) {
var listVariableDescriptorList =
entityClassToListVariableDescriptorListMap.get(genuineEntityDescriptor.getEntityClass());
if (listVariableDescriptorList.size() != 1) {
// TODO: Do multiple Construction Heuristics for each list variable descriptor?
throw new IllegalArgumentException(
"Construction Heuristic phase does not support multiple list variables ("
+ listVariableDescriptorList + ") for planning entity (" +
genuineEntityDescriptor.getEntityClass() + ").");
}
entityPlacerConfig =
DefaultConstructionHeuristicPhaseFactory.buildListVariableQueuedValuePlacerConfig(configPolicy,
listVariableDescriptorList.get(0));
} else {
entityPlacerConfig = new QueuedEntityPlacerConfig().withEntitySelectorConfig(AbstractFromConfigFactory
.getDefaultEntitySelectorConfigForEntity(configPolicy, genuineEntityDescriptor));
}
constructionHeuristicPhaseConfig.setEntityPlacerConfig(entityPlacerConfig);
phaseConfigList.add(constructionHeuristicPhaseConfig);
}
phaseConfigList.add(new LocalSearchPhaseConfig());
}
return PhaseFactory.buildPhases(phaseConfigList, configPolicy, bestSolutionRecaller, termination);
}
// Required for testability as final classes cannot be mocked.
static class MoveThreadCountResolver {
protected OptionalInt resolveMoveThreadCount(String moveThreadCount) {
return resolveMoveThreadCount(moveThreadCount, true);
}
protected OptionalInt resolveMoveThreadCount(String moveThreadCount, boolean enforceMaximum) {
int availableProcessorCount = getAvailableProcessors();
int resolvedMoveThreadCount;
if (moveThreadCount == null || moveThreadCount.equals(SolverConfig.MOVE_THREAD_COUNT_NONE)) {
return OptionalInt.empty();
} else if (moveThreadCount.equals(SolverConfig.MOVE_THREAD_COUNT_AUTO)) {
// Leave one for the Operating System and 1 for the solver thread, take the rest
resolvedMoveThreadCount = (availableProcessorCount - 2);
if (enforceMaximum && resolvedMoveThreadCount > 4) {
// A moveThreadCount beyond 4 is currently typically slower
// TODO remove limitation after fixing https://issues.redhat.com/browse/PLANNER-2449
resolvedMoveThreadCount = 4;
}
if (resolvedMoveThreadCount <= 1) {
// Fall back to single threaded solving with no move threads.
// To deliberately enforce 1 moveThread, set the moveThreadCount explicitly to 1.
return OptionalInt.empty();
}
} else {
resolvedMoveThreadCount = ConfigUtils.resolvePoolSize("moveThreadCount", moveThreadCount,
SolverConfig.MOVE_THREAD_COUNT_NONE, SolverConfig.MOVE_THREAD_COUNT_AUTO);
}
if (resolvedMoveThreadCount < 1) {
throw new IllegalArgumentException("The moveThreadCount (" + moveThreadCount
+ ") resulted in a resolvedMoveThreadCount (" + resolvedMoveThreadCount
+ ") that is lower than 1.");
}
if (resolvedMoveThreadCount > availableProcessorCount) {
LOGGER.warn("The resolvedMoveThreadCount ({}) is higher "
+ "than the availableProcessorCount ({}), which is counter-efficient.",
resolvedMoveThreadCount, availableProcessorCount);
// Still allow it, to reproduce issues of a high-end server machine on a low-end developer machine
}
return OptionalInt.of(resolvedMoveThreadCount);
}
protected int getAvailableProcessors() {
return Runtime.getRuntime().availableProcessors();
}
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.