index int64 | repo_id string | file_path string | content string |
|---|---|---|---|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/optional | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/optional/benchmark/TravelingTournamentBenchmarkApp.java | package ai.timefold.solver.examples.travelingtournament.optional.benchmark;
import ai.timefold.solver.examples.common.app.CommonBenchmarkApp;
public class TravelingTournamentBenchmarkApp extends CommonBenchmarkApp {
public static void main(String[] args) {
new TravelingTournamentBenchmarkApp().buildAndBenchmark(args);
}
public TravelingTournamentBenchmarkApp() {
super(
new ArgOption("default",
"ai/timefold/solver/examples/travelingtournament/optional/benchmark/travelingTournamentBenchmarkConfig.xml"),
new ArgOption("stepLimit",
"ai/timefold/solver/examples/travelingtournament/optional/benchmark/travelingTournamentStepLimitBenchmarkConfig.xml"));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/persistence/TravelingTournamentExporter.java | package ai.timefold.solver.examples.travelingtournament.persistence;
import java.io.IOException;
import ai.timefold.solver.examples.common.persistence.AbstractTxtSolutionExporter;
import ai.timefold.solver.examples.common.persistence.SolutionConverter;
import ai.timefold.solver.examples.travelingtournament.app.TravelingTournamentApp;
import ai.timefold.solver.examples.travelingtournament.domain.Day;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
import ai.timefold.solver.examples.travelingtournament.domain.Team;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
public class TravelingTournamentExporter extends AbstractTxtSolutionExporter<TravelingTournament> {
private static final String OUTPUT_FILE_SUFFIX = "trick.txt";
public static void main(String[] args) {
SolutionConverter<TravelingTournament> converter =
SolutionConverter.createExportConverter(TravelingTournamentApp.DATA_DIR_NAME,
new TravelingTournamentExporter(), new TravelingTournamentSolutionFileIO());
converter.convertAll();
}
@Override
public String getOutputFileSuffix() {
return OUTPUT_FILE_SUFFIX;
}
@Override
public TxtOutputBuilder<TravelingTournament> createTxtOutputBuilder() {
return new TravelingTournamentOutputBuilder();
}
public static class TravelingTournamentOutputBuilder extends TxtOutputBuilder<TravelingTournament> {
@Override
public void writeSolution() throws IOException {
int maximumTeamNameLength = 0;
for (Team team : solution.getTeamList()) {
if (team.getName().length() > maximumTeamNameLength) {
maximumTeamNameLength = team.getName().length();
}
}
for (Team team : solution.getTeamList()) {
bufferedWriter.write(String.format("%-" + (maximumTeamNameLength + 3) + "s", team.getName()));
}
bufferedWriter.write("\n");
for (Team team : solution.getTeamList()) {
bufferedWriter.write(
String.format("%-" + (maximumTeamNameLength + 3) + "s", team.getName().replaceAll("[\\w\\d]", "-")));
}
bufferedWriter.write("\n");
for (Day day : solution.getDayList()) {
for (Team team : solution.getTeamList()) {
// this could be put in a hashmap first for performance
boolean opponentIsHome = false;
Team opponentTeam = null;
for (Match match : solution.getMatchList()) {
if (match.getDay().equals(day)) {
if (match.getHomeTeam().equals(team)) {
opponentIsHome = false;
opponentTeam = match.getAwayTeam();
} else if (match.getAwayTeam().equals(team)) {
opponentIsHome = true;
opponentTeam = match.getHomeTeam();
}
}
}
if (opponentTeam != null) {
String opponentName = (opponentIsHome ? "@" : "") + opponentTeam.getName();
bufferedWriter.write(String.format("%-" + (maximumTeamNameLength + 3) + "s", opponentName));
}
}
bufferedWriter.write("\n");
}
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/persistence/TravelingTournamentImporter.java | package ai.timefold.solver.examples.travelingtournament.persistence;
import java.io.IOException;
import java.math.BigInteger;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.StringTokenizer;
import ai.timefold.solver.examples.common.persistence.AbstractTxtSolutionImporter;
import ai.timefold.solver.examples.common.persistence.SolutionConverter;
import ai.timefold.solver.examples.travelingtournament.app.TravelingTournamentApp;
import ai.timefold.solver.examples.travelingtournament.domain.Day;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
import ai.timefold.solver.examples.travelingtournament.domain.Team;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
public class TravelingTournamentImporter extends AbstractTxtSolutionImporter<TravelingTournament> {
public static void main(String[] args) {
SolutionConverter<TravelingTournament> converter =
SolutionConverter.createImportConverter(TravelingTournamentApp.DATA_DIR_NAME, new TravelingTournamentImporter(),
new TravelingTournamentSolutionFileIO());
converter.convertAll();
}
@Override
public TxtInputBuilder<TravelingTournament> createTxtInputBuilder() {
return new TravelingTournamentInputBuilder();
}
public static class TravelingTournamentInputBuilder extends TxtInputBuilder<TravelingTournament> {
@Override
public TravelingTournament readSolution() throws IOException {
TravelingTournament travelingTournament = new TravelingTournament(0L);
int n = readN();
readTeamList(travelingTournament, n);
createDayList(travelingTournament, n);
List<List<Integer>> outerDistanceList = readOuterDistanceList(travelingTournament);
// TODO setting the distances should be a separate method
createMatchListAndSetDistancesInTeamList(travelingTournament, outerDistanceList);
initializeMatchDays(travelingTournament);
BigInteger a = factorial(2 * (n - 1));
BigInteger possibleSolutionSize = (a == null) ? null : a.pow(n / 2);
logger.info("TravelingTournament {} has {} days, {} teams and {} matches with a search space of {}.",
getInputId(),
travelingTournament.getDayList().size(),
travelingTournament.getTeamList().size(),
travelingTournament.getMatchList().size(),
getFlooredPossibleSolutionSize(possibleSolutionSize));
return travelingTournament;
}
private int readN() throws IOException {
return Integer.parseInt(bufferedReader.readLine());
}
private void readTeamList(TravelingTournament travelingTournament, int n) throws IOException {
List<Team> teamList = new ArrayList<>();
for (int i = 0; i < n; i++) {
Team team = new Team(i, bufferedReader.readLine());
team.setDistanceToTeamMap(new LinkedHashMap<>());
teamList.add(team);
}
travelingTournament.setTeamList(teamList);
}
private List<List<Integer>> readOuterDistanceList(TravelingTournament travelingTournament) throws IOException {
List<List<Integer>> outerDistanceList = new ArrayList<>();
String line = bufferedReader.readLine();
while (line != null && !line.replaceAll("\\s+", "").equals("")) {
StringTokenizer tokenizer = new StringTokenizer(line.replaceAll("\\s+", " ").trim());
List<Integer> innerDistanceList = new ArrayList<>();
while (tokenizer.hasMoreTokens()) {
int distance = Integer.parseInt(tokenizer.nextToken());
innerDistanceList.add(distance);
}
outerDistanceList.add(innerDistanceList);
line = bufferedReader.readLine();
}
return outerDistanceList;
}
private void createDayList(TravelingTournament travelingTournament, int n) {
List<Day> dayList = new ArrayList<>();
int daySize = (n - 1) * 2; // Play vs each team (except itself) twice (home and away)
Day previousDay = null;
for (int i = 0; i < daySize; i++) {
Day day = new Day(i);
dayList.add(day);
if (previousDay != null) {
previousDay.setNextDay(day);
}
previousDay = day;
}
travelingTournament.setDayList(dayList);
}
private void createMatchListAndSetDistancesInTeamList(TravelingTournament travelingTournament,
List<List<Integer>> outerDistanceList) {
List<Team> teamList = travelingTournament.getTeamList();
List<Match> matchList = new ArrayList<>();
int i = 0;
long matchId = 0;
for (Team homeTeam : teamList) {
int j = 0;
for (Team awayTeam : teamList) {
int distance = outerDistanceList.get(i).get(j);
homeTeam.getDistanceToTeamMap().put(awayTeam, distance);
if (i != j) {
Match match = new Match(matchId, homeTeam, awayTeam);
matchId++;
matchList.add(match);
}
j++;
}
i++;
}
travelingTournament.setMatchList(matchList);
}
/**
* Canonical pattern initialization (see papers).
*
* @param travelingTournament the traveling tournament
*/
protected void initializeMatchDays(TravelingTournament travelingTournament) {
int n = travelingTournament.getN();
for (int i = 0; i < (n - 1); i++) {
initializeMatchPairs(travelingTournament, (n - 1), i, i);
}
for (int startA = 1, startB = (n - 2); startA < (n - 1); startA += 2, startB -= 2) {
for (int i = 0; i < (n - 1); i++) {
int a = (startA + i) % (n - 1);
int b = (startB + i) % (n - 1);
initializeMatchPairs(travelingTournament, a, b, i);
}
}
}
private void initializeMatchPairs(TravelingTournament travelingTournament, int a, int b, int i) {
if ((i % 6) >= 3) { // Might not be a 100% the canonical pattern
// Swap them
int oldA = a;
a = b;
b = oldA;
}
Team aTeam = travelingTournament.getTeamList().get(a);
Team bTeam = travelingTournament.getTeamList().get(b);
Match m1 = findMatch(travelingTournament.getMatchList(), aTeam, bTeam);
m1.setDay(travelingTournament.getDayList().get(i));
Match m2 = findMatch(travelingTournament.getMatchList(), bTeam, aTeam);
m2.setDay(travelingTournament.getDayList().get(i + travelingTournament.getN() - 1));
}
private Match findMatch(List<Match> matchList, Team homeTeam, Team awayTeam) {
for (Match match : matchList) {
if (match.getHomeTeam().equals(homeTeam) && match.getAwayTeam().equals(awayTeam)) {
return match;
}
}
throw new IllegalStateException("Nothing found for: " + homeTeam + " and " + awayTeam);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/persistence/TravelingTournamentSolutionFileIO.java | package ai.timefold.solver.examples.travelingtournament.persistence;
import java.io.File;
import java.util.function.Function;
import java.util.stream.Collectors;
import ai.timefold.solver.examples.common.persistence.AbstractJsonSolutionFileIO;
import ai.timefold.solver.examples.travelingtournament.domain.Team;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
public class TravelingTournamentSolutionFileIO extends AbstractJsonSolutionFileIO<TravelingTournament> {
public TravelingTournamentSolutionFileIO() {
super(TravelingTournament.class);
}
@Override
public TravelingTournament read(File inputSolutionFile) {
TravelingTournament travelingTournament = super.read(inputSolutionFile);
var teamsById = travelingTournament.getTeamList().stream()
.collect(Collectors.toMap(Team::getId, Function.identity()));
/*
* Replace the duplicate team instances in the distanceToTeamMap by references to instances from
* the teamList.
*/
for (Team team : travelingTournament.getTeamList()) {
var newTravelDistanceMap = deduplicateMap(team.getDistanceToTeamMap(),
teamsById, Team::getId);
team.setDistanceToTeamMap(newTravelDistanceMap);
}
return travelingTournament;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/score/TravelingTournamentConstraintProvider.java | package ai.timefold.solver.examples.travelingtournament.score;
import static ai.timefold.solver.core.api.score.stream.Joiners.equal;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintFactory;
import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
import ai.timefold.solver.examples.travelingtournament.domain.Day;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
public class TravelingTournamentConstraintProvider implements ConstraintProvider {
@Override
public Constraint[] defineConstraints(ConstraintFactory constraintFactory) {
return new Constraint[] {
fourConsecutiveHomeMatches(constraintFactory),
fourConsecutiveAwayMatches(constraintFactory),
repeatMatchOnTheNextDay(constraintFactory),
startToAwayHop(constraintFactory),
homeToAwayHop(constraintFactory),
awayToAwayHop(constraintFactory),
awayToHomeHop(constraintFactory),
awayToEndHop(constraintFactory)
};
}
private Constraint fourConsecutiveHomeMatches(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.ifExists(Match.class, equal(Match::getHomeTeam),
equal(match -> getDayIndex(match) + 1, TravelingTournamentConstraintProvider::getDayIndex))
.ifExists(Match.class, equal(Match::getHomeTeam),
equal(match -> getDayIndex(match) + 2, TravelingTournamentConstraintProvider::getDayIndex))
.ifExists(Match.class, equal(Match::getHomeTeam),
equal(match -> getDayIndex(match) + 3, TravelingTournamentConstraintProvider::getDayIndex))
.penalize(HardSoftScore.ONE_HARD)
.asConstraint("4 consecutive home matches");
}
private Constraint fourConsecutiveAwayMatches(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.ifExists(Match.class, equal(Match::getAwayTeam),
equal(match -> getDayIndex(match) + 1, TravelingTournamentConstraintProvider::getDayIndex))
.ifExists(Match.class, equal(Match::getAwayTeam),
equal(match -> getDayIndex(match) + 2, TravelingTournamentConstraintProvider::getDayIndex))
.ifExists(Match.class, equal(Match::getAwayTeam),
equal(match -> getDayIndex(match) + 3, TravelingTournamentConstraintProvider::getDayIndex))
.penalize(HardSoftScore.ONE_HARD)
.asConstraint("4 consecutive away matches");
}
private Constraint repeatMatchOnTheNextDay(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.ifExists(Match.class, equal(Match::getHomeTeam, Match::getAwayTeam),
equal(Match::getAwayTeam, Match::getHomeTeam),
equal(match -> getDayIndex(match) + 1, TravelingTournamentConstraintProvider::getDayIndex))
.penalize(HardSoftScore.ONE_HARD)
.asConstraint("Repeat match on the next day");
}
private Constraint startToAwayHop(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.ifNotExists(Day.class,
equal(match -> getDayIndex(match) - 1, Day::getIndex))
.penalize(HardSoftScore.ONE_SOFT,
match -> match.getAwayTeam().getDistance(match.getHomeTeam()))
.asConstraint("Start to away hop");
}
private Constraint homeToAwayHop(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.join(Match.class, equal(Match::getHomeTeam, Match::getAwayTeam),
equal(match -> getDayIndex(match) + 1, TravelingTournamentConstraintProvider::getDayIndex))
.penalize(HardSoftScore.ONE_SOFT,
(match, otherMatch) -> match.getHomeTeam().getDistance(otherMatch.getHomeTeam()))
.asConstraint("Home to away hop");
}
private Constraint awayToAwayHop(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.join(Match.class, equal(Match::getAwayTeam, Match::getAwayTeam),
equal(match -> getDayIndex(match) + 1, TravelingTournamentConstraintProvider::getDayIndex))
.penalize(HardSoftScore.ONE_SOFT,
(match, otherMatch) -> match.getHomeTeam().getDistance(otherMatch.getHomeTeam()))
.asConstraint("Away to away hop");
}
private Constraint awayToHomeHop(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.join(Match.class, equal(Match::getAwayTeam, Match::getHomeTeam),
equal(match -> getDayIndex(match) + 1, TravelingTournamentConstraintProvider::getDayIndex))
.penalize(HardSoftScore.ONE_SOFT,
(match, otherMatch) -> match.getHomeTeam().getDistance(match.getAwayTeam()))
.asConstraint("Away to home hop");
}
private Constraint awayToEndHop(ConstraintFactory constraintFactory) {
return constraintFactory.forEach(Match.class)
.ifNotExists(Day.class, equal(match -> getDayIndex(match) + 1, Day::getIndex))
.penalize(HardSoftScore.ONE_SOFT,
match -> match.getHomeTeam().getDistance(match.getAwayTeam()))
.asConstraint("Away to end hop");
}
private static int getDayIndex(Match match) {
return match.getDay().getIndex();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver/move/MatchChainRotationsMove.java | package ai.timefold.solver.examples.travelingtournament.solver.move;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.Objects;
import ai.timefold.solver.core.api.score.director.ScoreDirector;
import ai.timefold.solver.core.impl.heuristic.move.AbstractMove;
import ai.timefold.solver.core.impl.util.CollectionUtils;
import ai.timefold.solver.examples.travelingtournament.domain.Day;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
public class MatchChainRotationsMove extends AbstractMove<TravelingTournament> {
private List<Match> firstMatchList;
private List<Match> secondMatchList;
public MatchChainRotationsMove(List<Match> firstMatchList, List<Match> secondMatchList) {
this.firstMatchList = firstMatchList;
this.secondMatchList = secondMatchList;
}
@Override
public boolean isMoveDoable(ScoreDirector<TravelingTournament> scoreDirector) {
return true;
}
@Override
public MatchChainRotationsMove createUndoMove(ScoreDirector<TravelingTournament> scoreDirector) {
List<Match> inverseFirstMatchList = new ArrayList<>(firstMatchList);
Collections.reverse(inverseFirstMatchList);
List<Match> inverseSecondMatchList = new ArrayList<>(secondMatchList);
Collections.reverse(inverseSecondMatchList);
return new MatchChainRotationsMove(inverseFirstMatchList, inverseSecondMatchList);
}
@Override
protected void doMoveOnGenuineVariables(ScoreDirector<TravelingTournament> scoreDirector) {
rotateList(scoreDirector, firstMatchList);
if (!secondMatchList.isEmpty()) { // TODO create SingleMatchListRotateMove
rotateList(scoreDirector, secondMatchList);
}
}
private void rotateList(ScoreDirector<TravelingTournament> scoreDirector, List<Match> matchList) {
Iterator<Match> it = matchList.iterator();
Match previousMatch = it.next();
Match match = null;
Day firstDay = previousMatch.getDay();
while (it.hasNext()) {
match = it.next();
TravelingTournamentMoveHelper.moveDay(scoreDirector, previousMatch, match.getDay());
previousMatch = match;
}
TravelingTournamentMoveHelper.moveDay(scoreDirector, match, firstDay);
}
@Override
public MatchChainRotationsMove rebase(ScoreDirector<TravelingTournament> destinationScoreDirector) {
return new MatchChainRotationsMove(rebaseList(firstMatchList, destinationScoreDirector),
rebaseList(secondMatchList, destinationScoreDirector));
}
@Override
public Collection<? extends Object> getPlanningEntities() {
return CollectionUtils.concat(firstMatchList, secondMatchList);
}
@Override
public Collection<? extends Object> getPlanningValues() {
List<Day> values = new ArrayList<>(firstMatchList.size() + secondMatchList.size());
for (Match match : firstMatchList) {
values.add(match.getDay());
}
for (Match match : secondMatchList) {
values.add(match.getDay());
}
return values;
}
@Override
public boolean equals(Object o) {
if (this == o) {
return true;
}
if (o == null || getClass() != o.getClass()) {
return false;
}
final MatchChainRotationsMove other = (MatchChainRotationsMove) o;
return Objects.equals(firstMatchList, other.firstMatchList) &&
Objects.equals(secondMatchList, other.secondMatchList);
}
@Override
public int hashCode() {
return Objects.hash(firstMatchList, secondMatchList);
}
@Override
public String toString() {
return "Rotation " + firstMatchList + " & Rotation " + secondMatchList;
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver/move/TravelingTournamentMoveHelper.java | package ai.timefold.solver.examples.travelingtournament.solver.move;
import ai.timefold.solver.core.api.score.director.ScoreDirector;
import ai.timefold.solver.examples.travelingtournament.domain.Day;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
public class TravelingTournamentMoveHelper {
public static void moveDay(ScoreDirector<TravelingTournament> scoreDirector, Match match, Day toDay) {
scoreDirector.beforeVariableChanged(match, "day");
match.setDay(toDay);
scoreDirector.afterVariableChanged(match, "day");
}
private TravelingTournamentMoveHelper() {
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver/move | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver/move/factory/InverseMatchSwapMoveFilter.java | package ai.timefold.solver.examples.travelingtournament.solver.move.factory;
import ai.timefold.solver.core.api.score.director.ScoreDirector;
import ai.timefold.solver.core.impl.heuristic.selector.common.decorator.SelectionFilter;
import ai.timefold.solver.core.impl.heuristic.selector.move.generic.SwapMove;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
public class InverseMatchSwapMoveFilter implements SelectionFilter<TravelingTournament, SwapMove> {
@Override
public boolean accept(ScoreDirector<TravelingTournament> scoreDirector, SwapMove move) {
Match leftMatch = (Match) move.getLeftEntity();
Match rightMatch = (Match) move.getRightEntity();
return leftMatch.getHomeTeam().equals(rightMatch.getAwayTeam())
&& leftMatch.getAwayTeam().equals(rightMatch.getHomeTeam());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver/move | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/solver/move/factory/MatchChainRotationsMoveFactory.java | package ai.timefold.solver.examples.travelingtournament.solver.move.factory;
import java.util.ArrayList;
import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.ListIterator;
import java.util.Map;
import ai.timefold.solver.core.impl.heuristic.move.Move;
import ai.timefold.solver.core.impl.heuristic.selector.move.factory.MoveListFactory;
import ai.timefold.solver.examples.travelingtournament.domain.Day;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
import ai.timefold.solver.examples.travelingtournament.domain.Team;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
import ai.timefold.solver.examples.travelingtournament.solver.move.MatchChainRotationsMove;
public class MatchChainRotationsMoveFactory implements MoveListFactory<TravelingTournament> {
@Override
public List<Move<TravelingTournament>> createMoveList(TravelingTournament travelingTournament) {
List<Move<TravelingTournament>> moveList = new ArrayList<>();
RotationMovesFactory rotationMovesFactory = new RotationMovesFactory(travelingTournament);
rotationMovesFactory.addDayRotation(moveList);
rotationMovesFactory.addTeamRotation(moveList);
return moveList;
}
private static class RotationMovesFactory {
private List<Day> dayList;
private List<Team> teamList;
private List<Match> matchList;
private Map<Day, Map<Team, Match>> dayTeamMap;
private Map<Team, Map<Day, Match>> teamDayMap;
private Map<Team, Map<Team, Match>> homeTeamAwayTeamMap;
public RotationMovesFactory(TravelingTournament travelingTournament) {
dayList = travelingTournament.getDayList();
teamList = travelingTournament.getTeamList();
matchList = travelingTournament.getMatchList();
createMaps();
}
private void createMaps() {
dayTeamMap = new HashMap<>(dayList.size());
for (Day day : dayList) {
// This map should be ordered so the order of the matchRotationList is the same (when it's used as tabu)
dayTeamMap.put(day, new LinkedHashMap<>(teamList.size()));
}
teamDayMap = new HashMap<>(teamList.size());
homeTeamAwayTeamMap = new HashMap<>(teamList.size());
for (Team team : teamList) {
// This map should be ordered so the order of the matchRotationList is the same (when it's used as tabu)
teamDayMap.put(team, new LinkedHashMap<>(dayList.size()));
homeTeamAwayTeamMap.put(team, new LinkedHashMap<>(teamList.size() - 1));
}
for (Match match : matchList) {
Map<Team, Match> subTeamMap = dayTeamMap.get(match.getDay());
subTeamMap.put(match.getHomeTeam(), match);
subTeamMap.put(match.getAwayTeam(), match);
teamDayMap.get(match.getHomeTeam()).put(match.getDay(), match);
teamDayMap.get(match.getAwayTeam()).put(match.getDay(), match);
homeTeamAwayTeamMap.get(match.getHomeTeam()).put(match.getAwayTeam(), match);
}
}
private Team getOtherTeam(Match match, Team team) {
return match.getHomeTeam().equals(team) ? match.getAwayTeam() : match.getHomeTeam();
}
/**
* @TODO clean up this code
*/
private void addDayRotation(List<Move<TravelingTournament>> moveList) {
for (ListIterator<Day> firstDayIt = dayList.listIterator(); firstDayIt.hasNext();) {
Day firstDay = firstDayIt.next();
Map<Team, Match> firstDayTeamMap = dayTeamMap.get(firstDay);
for (ListIterator<Day> secondDayIt = dayList.listIterator(firstDayIt.nextIndex()); secondDayIt.hasNext();) {
Day secondDay = secondDayIt.next();
List<Match> clonedFirstDayMatchList = new ArrayList<>(firstDayTeamMap.values());
while (!clonedFirstDayMatchList.isEmpty()) {
List<Match> rotateList = new ArrayList<>(4);
Match startMatch = clonedFirstDayMatchList.remove(0);
boolean otherInFirst = false;
rotateList.add(startMatch);
Team startHomeTeam = startMatch.getHomeTeam();
Team nextTeamToFind = startMatch.getAwayTeam();
while (!startHomeTeam.equals(nextTeamToFind)) {
Map<Team, Match> subTeamMap = dayTeamMap.get(otherInFirst ? firstDay : secondDay);
Match repairMatch = subTeamMap.get(nextTeamToFind);
if (otherInFirst) {
clonedFirstDayMatchList.remove(repairMatch);
}
rotateList.add(repairMatch);
nextTeamToFind = getOtherTeam(repairMatch, nextTeamToFind);
otherInFirst = !otherInFirst;
}
// assert(rotateList.size() % 2 == 0);
// if size is 2 then addCachedHomeAwaySwapMoves will have done it
if (rotateList.size() > 2) {
List<Match> emptyList = Collections.emptyList();
MatchChainRotationsMove rotateMove = new MatchChainRotationsMove(rotateList, emptyList);
moveList.add(rotateMove);
}
}
}
}
}
/**
* @TODO clean up this code
*/
private void addTeamRotation(List<Move<TravelingTournament>> moveList) {
for (ListIterator<Team> firstTeamIt = teamList.listIterator(); firstTeamIt.hasNext();) {
Team firstTeam = firstTeamIt.next();
Map<Day, Match> firstTeamDayMap = teamDayMap.get(firstTeam);
for (ListIterator<Team> secondTeamIt = teamList.listIterator(firstTeamIt.nextIndex()); secondTeamIt
.hasNext();) {
Team secondTeam = secondTeamIt.next();
List<Match> clonedFirstTeamMatchList = new ArrayList<>(firstTeamDayMap.values());
while (!clonedFirstTeamMatchList.isEmpty()) {
List<Match> firstRotateList = new ArrayList<>();
List<Match> secondRotateList = new ArrayList<>();
Match firstStartMatch = clonedFirstTeamMatchList.remove(0);
Team firstStartTeam = getOtherTeam(firstStartMatch, firstTeam);
Day startDay = firstStartMatch.getDay();
boolean firstTeamIsHomeTeam = firstStartMatch.getHomeTeam().equals(firstTeam);
Match secondStartMatch = teamDayMap.get(secondTeam).get(startDay);
if (firstStartMatch.equals(secondStartMatch)) {
break;
}
firstRotateList.add(0, firstStartMatch);
secondRotateList.add(secondStartMatch);
Map<Team, Match> visitedTeamMap = new HashMap<>();
Team teamToFind = getOtherTeam(secondStartMatch, secondTeam);
while (!teamToFind.equals(firstStartTeam)) {
// boolean shortcut = visitedTeamMap.containsKey(teamToFind);
// if (shortcut) {
Match firstRepairMatch = homeTeamAwayTeamMap
.get(firstTeamIsHomeTeam ? firstTeam : teamToFind)
.get(firstTeamIsHomeTeam ? teamToFind : firstTeam);
if (!clonedFirstTeamMatchList.contains(firstRepairMatch)) {
if (visitedTeamMap.containsKey(teamToFind)) {
// shortcut splitoff is possible
Match shortcutMatch = visitedTeamMap.get(teamToFind);
int shortcutSize = firstRotateList.indexOf(shortcutMatch) + 1;
int reverseShortcutSize = firstRotateList.size() - shortcutSize;
List<Match> firstShortcutRotateList = new ArrayList<>(
firstRotateList.subList(0, shortcutSize));
for (Match match : firstShortcutRotateList) {
visitedTeamMap.remove(getOtherTeam(match, firstTeam));
}
List<Match> secondShortcutRotateList = new ArrayList<>(
secondRotateList.subList(reverseShortcutSize, secondRotateList.size()));
firstRotateList = new ArrayList<>(
firstRotateList.subList(shortcutSize, firstRotateList.size()));
secondRotateList = new ArrayList<>(
secondRotateList.subList(0, reverseShortcutSize));
addTeamRotateMove(moveList, firstShortcutRotateList, secondShortcutRotateList);
}
firstTeamIsHomeTeam = !firstTeamIsHomeTeam;
// Team firstRepairHomeTeam = (firstTeamIsHomeTeam ^ shortcut) ? firstTeam : teamToFind;
// Team firstRepairAwayTeam = (firstTeamIsHomeTeam ^ shortcut) ? teamToFind : firstTeam;
// Match firstRepairMatch = homeTeamAwayTeamMap
// .get(firstRepairHomeTeam).get(firstRepairAwayTeam);
firstRepairMatch = homeTeamAwayTeamMap
.get(firstTeamIsHomeTeam ? firstTeam : teamToFind)
.get(firstTeamIsHomeTeam ? teamToFind : firstTeam);
}
Day repairDay = firstRepairMatch.getDay();
Match secondRepairMatch = teamDayMap.get(secondTeam).get(repairDay);
clonedFirstTeamMatchList.remove(firstRepairMatch);
visitedTeamMap.put(teamToFind, firstRepairMatch);
firstRotateList.add(0, firstRepairMatch);
secondRotateList.add(secondRepairMatch);
teamToFind = getOtherTeam(secondRepairMatch, secondTeam);
}
addTeamRotateMove(moveList, firstRotateList, secondRotateList);
}
}
}
}
private void addTeamRotateMove(List<Move<TravelingTournament>> moveList,
List<Match> firstRotateList, List<Match> secondRotateList) {
assert (firstRotateList.size() == secondRotateList.size());
// if size is 1 then addCachedHomeAwaySwapMoves will have done it
// if size is 2 then addDayRotation will have done it by 1 list of size 4
if (firstRotateList.size() > 2) {
MatchChainRotationsMove rotateMove = new MatchChainRotationsMove(firstRotateList, secondRotateList);
moveList.add(rotateMove);
}
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament | java-sources/ai/timefold/solver/timefold-solver-examples/1.9.0/ai/timefold/solver/examples/travelingtournament/swingui/TravelingTournamentPanel.java | package ai.timefold.solver.examples.travelingtournament.swingui;
import static ai.timefold.solver.examples.common.swingui.timetable.TimeTablePanel.HeaderColumnKey.HEADER_COLUMN;
import static ai.timefold.solver.examples.common.swingui.timetable.TimeTablePanel.HeaderRowKey.HEADER_ROW;
import java.awt.BorderLayout;
import java.awt.Color;
import java.awt.event.ActionEvent;
import java.util.List;
import javax.swing.AbstractAction;
import javax.swing.BorderFactory;
import javax.swing.ImageIcon;
import javax.swing.JButton;
import javax.swing.JComboBox;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
import javax.swing.JPanel;
import javax.swing.JScrollPane;
import javax.swing.JTabbedPane;
import javax.swing.SwingConstants;
import ai.timefold.solver.examples.common.swingui.SolutionPanel;
import ai.timefold.solver.examples.common.swingui.components.LabeledComboBoxRenderer;
import ai.timefold.solver.examples.common.swingui.timetable.TimeTablePanel;
import ai.timefold.solver.examples.travelingtournament.domain.Day;
import ai.timefold.solver.examples.travelingtournament.domain.Match;
import ai.timefold.solver.examples.travelingtournament.domain.Team;
import ai.timefold.solver.examples.travelingtournament.domain.TravelingTournament;
import ai.timefold.solver.swing.impl.SwingUtils;
import ai.timefold.solver.swing.impl.TangoColorFactory;
public class TravelingTournamentPanel extends SolutionPanel<TravelingTournament> {
public static final String LOGO_PATH =
"/ai/timefold/solver/examples/travelingtournament/swingui/travelingTournamentLogo.png";
private ImageIcon awayMatchIcon;
private final TimeTablePanel<Team, Day> teamsPanel;
private TangoColorFactory tangoColorFactory;
public TravelingTournamentPanel() {
awayMatchIcon = new ImageIcon(getClass().getResource("awayMatch.png"));
setLayout(new BorderLayout());
JTabbedPane tabbedPane = new JTabbedPane();
teamsPanel = new TimeTablePanel<>();
tabbedPane.add("Teams", new JScrollPane(teamsPanel));
add(tabbedPane, BorderLayout.CENTER);
setPreferredSize(PREFERRED_SCROLLABLE_VIEWPORT_SIZE);
}
@Override
public boolean isWrapInScrollPane() {
return false;
}
@Override
public void resetPanel(TravelingTournament travelingTournament) {
teamsPanel.reset();
tangoColorFactory = new TangoColorFactory();
defineGrid(travelingTournament);
fillCells(travelingTournament);
repaint(); // Hack to force a repaint of TimeTableLayout during "refresh screen while solving"
}
private void defineGrid(TravelingTournament travelingTournament) {
JButton footprint = SwingUtils.makeSmallButton(new JButton("MMMMM"));
int footprintWidth = footprint.getPreferredSize().width;
teamsPanel.defineColumnHeaderByKey(HEADER_COLUMN); // Day header
for (Team team : travelingTournament.getTeamList()) {
teamsPanel.defineColumnHeader(team, footprintWidth);
}
teamsPanel.defineColumnHeader(null, footprintWidth); // Unassigned
teamsPanel.defineRowHeaderByKey(HEADER_ROW); // Team header
for (Day day : travelingTournament.getDayList()) {
teamsPanel.defineRowHeader(day);
}
teamsPanel.defineRowHeader(null); // Unassigned day
}
private void fillCells(TravelingTournament travelingTournament) {
teamsPanel.addCornerHeader(HEADER_COLUMN, HEADER_ROW, createTableHeader(new JLabel("Day")));
fillTeamCells(travelingTournament);
fillDayCells(travelingTournament);
fillMatchCells(travelingTournament);
}
private void fillTeamCells(TravelingTournament travelingTournament) {
for (Team team : travelingTournament.getTeamList()) {
JPanel teamPanel = createTableHeader(new JLabel(team.getLabel(), SwingConstants.CENTER));
teamPanel.setBackground(tangoColorFactory.pickColor(team));
teamsPanel.addColumnHeader(team, HEADER_ROW,
teamPanel);
}
teamsPanel.addColumnHeader(null, HEADER_ROW,
createTableHeader(new JLabel("Unassigned", SwingConstants.CENTER)));
}
private void fillDayCells(TravelingTournament travelingTournament) {
for (Day day : travelingTournament.getDayList()) {
teamsPanel.addRowHeader(HEADER_COLUMN, day,
createTableHeader(new JLabel(day.getLabel())));
}
teamsPanel.addRowHeader(HEADER_COLUMN, null,
createTableHeader(new JLabel("Unassigned")));
}
private void fillMatchCells(TravelingTournament travelingTournament) {
preparePlanningEntityColors(travelingTournament.getMatchList());
for (Match match : travelingTournament.getMatchList()) {
Team homeTeam = match.getHomeTeam();
Team awayTeam = match.getAwayTeam();
String toolTip = determinePlanningEntityTooltip(match);
teamsPanel.addCell(homeTeam, match.getDay(),
createButton(match, homeTeam, awayTeam, toolTip));
teamsPanel.addCell(awayTeam, match.getDay(),
createButton(match, awayTeam, homeTeam, toolTip));
}
}
private JPanel createTableHeader(JLabel label) {
JPanel headerPanel = new JPanel(new BorderLayout());
headerPanel.add(label, BorderLayout.NORTH);
headerPanel.setBorder(BorderFactory.createCompoundBorder(
BorderFactory.createLineBorder(TangoColorFactory.ALUMINIUM_5),
BorderFactory.createEmptyBorder(2, 2, 2, 2)));
return headerPanel;
}
private JButton createButton(Match match, Team team, Team otherTeam, String toolTip) {
Color color = determinePlanningEntityColor(match, otherTeam);
String label = otherTeam.getLabel();
JButton button = SwingUtils.makeSmallButton(new JButton(new MatchAction(match, label)));
if (match.getAwayTeam() == team) {
button.setIcon(awayMatchIcon);
}
button.setBackground(color);
button.setToolTipText(toolTip);
return button;
}
@Override
public boolean isIndictmentHeatMapEnabled() {
return true;
}
private class MatchAction extends AbstractAction {
private Match match;
public MatchAction(Match match, String label) {
super(label);
this.match = match;
}
@Override
public void actionPerformed(ActionEvent e) {
// TODO this allows the user to put the TTP in an inconsistent state, from which the solver cannot start
List<Day> dayList = getSolution().getDayList();
// Add 1 to array size to add null, which makes the entity unassigned
JComboBox dayListField = new JComboBox(
dayList.toArray(new Object[dayList.size() + 1]));
LabeledComboBoxRenderer.applyToComboBox(dayListField);
dayListField.setSelectedItem(match.getDay());
int result = JOptionPane.showConfirmDialog(TravelingTournamentPanel.this.getRootPane(), dayListField,
"Select day", JOptionPane.OK_CANCEL_OPTION);
if (result == JOptionPane.OK_OPTION) {
Day toDay = (Day) dayListField.getSelectedItem();
doProblemChange((workingSolution, problemChangeDirector) -> problemChangeDirector.changeVariable(match, "day",
m -> m.setDay(toDay)));
solverAndPersistenceFrame.resetScreen();
}
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/TimefoldJacksonModule.java | package ai.timefold.solver.jackson.api;
import ai.timefold.solver.core.api.domain.solution.ConstraintWeightOverrides;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.analysis.ScoreAnalysis;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.common.Break;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import ai.timefold.solver.core.api.score.stream.common.Sequence;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import ai.timefold.solver.core.api.solver.RecommendedAssignment;
import ai.timefold.solver.core.api.solver.RecommendedFit;
import ai.timefold.solver.core.impl.domain.solution.DefaultConstraintWeightOverrides;
import ai.timefold.solver.core.impl.solver.DefaultRecommendedAssignment;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningEntityDiff;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningSolutionDiff;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningVariableDiff;
import ai.timefold.solver.jackson.api.domain.solution.ConstraintWeightOverridesSerializer;
import ai.timefold.solver.jackson.api.score.PolymorphicScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.PolymorphicScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.analysis.ScoreAnalysisJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.bendable.BendableScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.bendable.BendableScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.bendablebigdecimal.BendableBigDecimalScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.bendablebigdecimal.BendableBigDecimalScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.bendablelong.BendableLongScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.bendablelong.BendableLongScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.hardmediumsoft.HardMediumSoftScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.hardmediumsoft.HardMediumSoftScoreJsonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.hardsoft.HardSoftScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.hardsoft.HardSoftScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.hardsoftlong.HardSoftLongScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.hardsoftlong.HardSoftLongScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.simple.SimpleScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.simple.SimpleScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.simplebigdecimal.SimpleBigDecimalScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.simplebigdecimal.SimpleBigDecimalScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.buildin.simplelong.SimpleLongScoreJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.buildin.simplelong.SimpleLongScoreJacksonSerializer;
import ai.timefold.solver.jackson.api.score.constraint.ConstraintRefJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.constraint.ConstraintRefJacksonSerializer;
import ai.timefold.solver.jackson.api.score.stream.common.BreakJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.stream.common.BreakJacksonSerializer;
import ai.timefold.solver.jackson.api.score.stream.common.LoadBalanceJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.stream.common.LoadBalanceJacksonSerializer;
import ai.timefold.solver.jackson.api.score.stream.common.SequenceChainJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.stream.common.SequenceChainJacksonSerializer;
import ai.timefold.solver.jackson.api.score.stream.common.SequenceJacksonDeserializer;
import ai.timefold.solver.jackson.api.score.stream.common.SequenceJacksonSerializer;
import ai.timefold.solver.jackson.api.solver.RecommendedAssignmentJacksonSerializer;
import ai.timefold.solver.jackson.api.solver.RecommendedFitJacksonSerializer;
import ai.timefold.solver.jackson.impl.domain.solution.JacksonSolutionFileIO;
import ai.timefold.solver.jackson.preview.api.domain.solution.diff.PlanningEntityDiffJacksonSerializer;
import ai.timefold.solver.jackson.preview.api.domain.solution.diff.PlanningSolutionDiffJacksonSerializer;
import ai.timefold.solver.jackson.preview.api.domain.solution.diff.PlanningVariableDiffJacksonSerializer;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.Module;
import com.fasterxml.jackson.databind.ObjectMapper;
import com.fasterxml.jackson.databind.module.SimpleModule;
/**
* This class adds all Jackson serializers and deserializers.
*/
public class TimefoldJacksonModule extends SimpleModule {
/**
* Jackson modules can be loaded automatically via {@link java.util.ServiceLoader}.
* This will happen if you use {@link JacksonSolutionFileIO}.
* Otherwise, register the module with {@link ObjectMapper#registerModule(Module)}.
*
* @return never null
*/
public static Module createModule() {
return new TimefoldJacksonModule();
}
/**
* @deprecated Have the module loaded automatically via {@link JacksonSolutionFileIO} or use {@link #createModule()}.
* This constructor will be hidden in a future major version of Timefold.
*/
@SuppressWarnings({ "rawtypes", "unchecked" })
@Deprecated(forRemoval = true)
public TimefoldJacksonModule() {
super("Timefold");
// For non-subtype Score fields/properties, we also need to record the score type
addSerializer(Score.class, new PolymorphicScoreJacksonSerializer());
addDeserializer(Score.class, new PolymorphicScoreJacksonDeserializer());
addSerializer(SimpleScore.class, new SimpleScoreJacksonSerializer());
addDeserializer(SimpleScore.class, new SimpleScoreJacksonDeserializer());
addSerializer(SimpleLongScore.class, new SimpleLongScoreJacksonSerializer());
addDeserializer(SimpleLongScore.class, new SimpleLongScoreJacksonDeserializer());
addSerializer(SimpleBigDecimalScore.class, new SimpleBigDecimalScoreJacksonSerializer());
addDeserializer(SimpleBigDecimalScore.class, new SimpleBigDecimalScoreJacksonDeserializer());
addSerializer(HardSoftScore.class, new HardSoftScoreJacksonSerializer());
addDeserializer(HardSoftScore.class, new HardSoftScoreJacksonDeserializer());
addSerializer(HardSoftLongScore.class, new HardSoftLongScoreJacksonSerializer());
addDeserializer(HardSoftLongScore.class, new HardSoftLongScoreJacksonDeserializer());
addSerializer(HardSoftBigDecimalScore.class, new HardSoftBigDecimalScoreJacksonSerializer());
addDeserializer(HardSoftBigDecimalScore.class, new HardSoftBigDecimalScoreJacksonDeserializer());
addSerializer(HardMediumSoftScore.class, new HardMediumSoftScoreJsonSerializer());
addDeserializer(HardMediumSoftScore.class, new HardMediumSoftScoreJacksonDeserializer());
addSerializer(HardMediumSoftLongScore.class, new HardMediumSoftLongScoreJacksonSerializer());
addDeserializer(HardMediumSoftLongScore.class, new HardMediumSoftLongScoreJacksonDeserializer());
addSerializer(HardMediumSoftBigDecimalScore.class, new HardMediumSoftBigDecimalScoreJacksonSerializer());
addDeserializer(HardMediumSoftBigDecimalScore.class, new HardMediumSoftBigDecimalScoreJacksonDeserializer());
addSerializer(BendableScore.class, new BendableScoreJacksonSerializer());
addDeserializer(BendableScore.class, new BendableScoreJacksonDeserializer());
addSerializer(BendableLongScore.class, new BendableLongScoreJacksonSerializer());
addDeserializer(BendableLongScore.class, new BendableLongScoreJacksonDeserializer());
addSerializer(BendableBigDecimalScore.class, new BendableBigDecimalScoreJacksonSerializer());
addDeserializer(BendableBigDecimalScore.class, new BendableBigDecimalScoreJacksonDeserializer());
// Score analysis
addSerializer(ConstraintRef.class, new ConstraintRefJacksonSerializer());
addDeserializer(ConstraintRef.class, new ConstraintRefJacksonDeserializer());
addSerializer(ScoreAnalysis.class, new ScoreAnalysisJacksonSerializer());
var serializer = (JsonSerializer) new RecommendedAssignmentJacksonSerializer<>();
addSerializer(RecommendedAssignment.class, serializer);
addSerializer(DefaultRecommendedAssignment.class, serializer);
addSerializer(RecommendedFit.class, (JsonSerializer) new RecommendedFitJacksonSerializer<>());
// Constraint weights
addSerializer(ConstraintWeightOverrides.class, new ConstraintWeightOverridesSerializer());
addSerializer(DefaultConstraintWeightOverrides.class, new ConstraintWeightOverridesSerializer());
// Constraint collectors
addSerializer(Break.class, new BreakJacksonSerializer());
addDeserializer(Break.class, new BreakJacksonDeserializer<>());
addSerializer(Sequence.class, new SequenceJacksonSerializer());
addDeserializer(Sequence.class, new SequenceJacksonDeserializer<>());
addSerializer(SequenceChain.class, new SequenceChainJacksonSerializer());
addDeserializer(SequenceChain.class, new SequenceChainJacksonDeserializer<>());
addSerializer(LoadBalance.class, new LoadBalanceJacksonSerializer());
addDeserializer(LoadBalance.class, new LoadBalanceJacksonDeserializer<>());
// Solution diff
addSerializer(PlanningSolutionDiff.class, new PlanningSolutionDiffJacksonSerializer());
addSerializer(PlanningEntityDiff.class, new PlanningEntityDiffJacksonSerializer());
addSerializer(PlanningVariableDiff.class, new PlanningVariableDiffJacksonSerializer());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/package-info.java |
/**
* Jackson bindings.
*/
package ai.timefold.solver.jackson.api;
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/domain | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/domain/solution/AbstractConstraintWeightOverridesDeserializer.java | package ai.timefold.solver.jackson.api.domain.solution;
import java.io.IOException;
import java.util.LinkedHashMap;
import ai.timefold.solver.core.api.domain.solution.ConstraintWeightOverrides;
import ai.timefold.solver.core.api.score.Score;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
/**
* Extend this to implement {@link ConstraintWeightOverrides} deserialization specific for your domain.
*
* @param <Score_>
*/
public abstract class AbstractConstraintWeightOverridesDeserializer<Score_ extends Score<Score_>>
extends JsonDeserializer<ConstraintWeightOverrides<Score_>> {
@Override
public final ConstraintWeightOverrides<Score_> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
var resultMap = new LinkedHashMap<String, Score_>();
JsonNode node = p.readValueAsTree();
node.fields().forEachRemaining(entry -> {
var constraintName = entry.getKey();
var weight = parseScore(entry.getValue().asText());
resultMap.put(constraintName, weight);
});
return ConstraintWeightOverrides.of(resultMap);
}
/**
* The domain is based on a single {@link Score} subtype.
* This method is responsible for parsing the score string into that subtype.
*
* @param scoreString never null
* @return never null
*/
protected abstract Score_ parseScore(String scoreString);
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/domain | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/domain/solution/ConstraintWeightOverridesSerializer.java | package ai.timefold.solver.jackson.api.domain.solution;
import java.io.IOException;
import java.util.Objects;
import ai.timefold.solver.core.api.domain.solution.ConstraintWeightOverrides;
import ai.timefold.solver.core.api.score.Score;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class ConstraintWeightOverridesSerializer<Score_ extends Score<Score_>>
extends JsonSerializer<ConstraintWeightOverrides<Score_>> {
@Override
public void serialize(ConstraintWeightOverrides<Score_> constraintWeightOverrides, JsonGenerator generator,
SerializerProvider serializerProvider) throws IOException {
generator.writeStartObject();
for (var constraintName : constraintWeightOverrides.getKnownConstraintNames()) {
var weight = Objects.requireNonNull(constraintWeightOverrides.getConstraintWeight(constraintName));
generator.writeStringField(constraintName, weight.toString());
}
generator.writeEndObject();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/AbstractScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score;
import ai.timefold.solver.core.api.score.Score;
import com.fasterxml.jackson.databind.JsonDeserializer;
/**
* Jackson binding support for a {@link Score} type.
* <p>
* For example: use
* {@code @JsonSerialize(using = HardSoftScoreScoreJacksonSerializer.class) @JsonDeserialize(using = HardSoftScoreJacksonDeserializer.class)}
* on a {@code HardSoftScore score} field and it will marshalled to JSON as {@code "score":"-999hard/-999soft"}.
*
* @see Score
* @param <Score_> the actual score type
*/
public abstract class AbstractScoreJacksonDeserializer<Score_ extends Score<Score_>>
extends JsonDeserializer<Score_> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/AbstractScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score;
import java.io.IOException;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.jackson.api.TimefoldJacksonModule;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.BeanProperty;
import com.fasterxml.jackson.databind.JavaType;
import com.fasterxml.jackson.databind.JsonMappingException;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
import com.fasterxml.jackson.databind.ser.ContextualSerializer;
/**
* Jackson binding support for a {@link Score} subtype.
* For a {@link Score} field, use {@link PolymorphicScoreJacksonSerializer} instead,
* so the score type is recorded too and it can be deserialized.
* <p>
* For example: use
* {@code @JsonSerialize(using = HardSoftScoreJacksonSerializer.class) @JsonDeserialize(using = HardSoftScoreJacksonDeserializer.class)}
* on a {@code HardSoftScore score} field and it will marshalled to JSON as {@code "score":"-999hard/-999soft"}.
* Or better yet, use {@link TimefoldJacksonModule} instead.
*
* @see Score
* @param <Score_> the actual score type
*/
public abstract class AbstractScoreJacksonSerializer<Score_ extends Score<Score_>> extends JsonSerializer<Score_>
implements ContextualSerializer {
@Override
public JsonSerializer<?> createContextual(SerializerProvider provider, BeanProperty property)
throws JsonMappingException {
JavaType propertyType = property.getType();
if (Score.class.equals(propertyType.getRawClass())) {
// If the property type is Score (not HardSoftScore for example),
// delegate to PolymorphicScoreJacksonSerializer instead to write the score type too
// This presumes that TimefoldJacksonModule is registered
return provider.findValueSerializer(propertyType);
}
return this;
}
@Override
public void serialize(Score_ score, JsonGenerator generator, SerializerProvider serializers) throws IOException {
generator.writeString(score.toString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/PolymorphicScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score;
import java.io.IOException;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.jackson.api.score.buildin.hardsoft.HardSoftScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
/**
* Jackson binding support for a {@link Score} type (but not a subtype).
* For a {@link Score} subtype field, use {@link HardSoftScoreJacksonDeserializer} or similar instead.
* <p>
* For example: use
* {@code @JsonSerialize(using = PolymorphicScoreJacksonSerializer.class) @JsonDeserialize(using = PolymorphicScoreJacksonDeserializer.class)}
* on a {@code Score score} field which contains a {@link HardSoftScore} instance
* and it will marshalled to JSON as {@code "score":{"type":"HARD_SOFT",score:"-999hard/-999soft"}}.
*
* @see Score
* @see PolymorphicScoreJacksonDeserializer
*/
public class PolymorphicScoreJacksonDeserializer extends JsonDeserializer<Score> {
@Override
public Score deserialize(JsonParser parser, DeserializationContext context) throws IOException {
parser.nextToken();
String scoreClassSimpleName = parser.getCurrentName();
parser.nextToken();
String scoreString = parser.getValueAsString();
if (scoreClassSimpleName.equals(SimpleScore.class.getSimpleName())) {
return SimpleScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(SimpleLongScore.class.getSimpleName())) {
return SimpleLongScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(SimpleBigDecimalScore.class.getSimpleName())) {
return SimpleBigDecimalScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(HardSoftScore.class.getSimpleName())) {
return HardSoftScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(HardSoftLongScore.class.getSimpleName())) {
return HardSoftLongScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(HardSoftBigDecimalScore.class.getSimpleName())) {
return HardSoftBigDecimalScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(HardMediumSoftScore.class.getSimpleName())) {
return HardMediumSoftScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(HardMediumSoftLongScore.class.getSimpleName())) {
return HardMediumSoftLongScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(HardMediumSoftBigDecimalScore.class.getSimpleName())) {
return HardMediumSoftBigDecimalScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(BendableScore.class.getSimpleName())) {
return BendableScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(BendableLongScore.class.getSimpleName())) {
return BendableLongScore.parseScore(scoreString);
} else if (scoreClassSimpleName.equals(BendableBigDecimalScore.class.getSimpleName())) {
return BendableBigDecimalScore.parseScore(scoreString);
} else {
throw new IllegalArgumentException("Unrecognized scoreClassSimpleName (" + scoreClassSimpleName
+ ") for scoreString (" + scoreString + ").");
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/PolymorphicScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score;
import java.io.IOException;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.jackson.api.score.buildin.hardsoft.HardSoftScoreJacksonSerializer;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
/**
* Jackson binding support for a {@link Score} type (but not a subtype).
* For a {@link Score} subtype field, use {@link HardSoftScoreJacksonSerializer} or similar instead.
* <p>
* For example: use
* {@code @JsonSerialize(using = PolymorphicScoreJacksonSerializer.class) @JsonDeserialize(using = PolymorphicScoreJacksonDeserializer.class)}
* on a {@code Score score} field which contains a {@link HardSoftScore} instance
* and it will marshalled to JSON as {@code "score":{"type":"HARD_SOFT",score:"-999hard/-999soft"}}.
*
* @see Score
* @see PolymorphicScoreJacksonDeserializer
*/
public class PolymorphicScoreJacksonSerializer extends JsonSerializer<Score> {
@Override
public void serialize(Score score, JsonGenerator generator, SerializerProvider serializers) throws IOException {
generator.writeStartObject();
generator.writeStringField(score.getClass().getSimpleName(), score.toString());
generator.writeEndObject();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/package-info.java |
/**
* Jackson bindings for {@link ai.timefold.solver.core.api.score.Score}.
*/
package ai.timefold.solver.jackson.api.score;
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/analysis/AbstractScoreAnalysisJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.analysis;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.analysis.ConstraintAnalysis;
import ai.timefold.solver.core.api.score.analysis.MatchAnalysis;
import ai.timefold.solver.core.api.score.analysis.ScoreAnalysis;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import ai.timefold.solver.core.api.score.stream.Constraint;
import ai.timefold.solver.core.api.score.stream.ConstraintJustification;
import ai.timefold.solver.core.api.score.stream.ConstraintProvider;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
/**
* Extend this to implement {@link ScoreAnalysis} deserialization specific for your domain.
*
* @param <Score_>
*/
public abstract class AbstractScoreAnalysisJacksonDeserializer<Score_ extends Score<Score_>>
extends JsonDeserializer<ScoreAnalysis<Score_>> {
@Override
public final ScoreAnalysis<Score_> deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
JsonNode node = p.readValueAsTree();
var score = parseScore(node.get("score").asText());
var initialized = node.get("initialized").asBoolean();
var constraintAnalysisList = new HashMap<ConstraintRef, ConstraintAnalysis<Score_>>();
for (var constraintNode : node.get("constraints")) {
var constraintPackage = constraintNode.get("package").asText();
var constraintName = constraintNode.get("name").asText();
var constraintRef = ConstraintRef.of(constraintPackage, constraintName);
var constraintWeight = parseScore(constraintNode.get("weight").asText());
var constraintScore = parseScore(constraintNode.get("score").asText());
var matchScoreList = new ArrayList<MatchAnalysis<Score_>>();
var matchesNode = constraintNode.get("matches");
var matchCountNode = constraintNode.get("matchCount");
if (matchesNode == null) {
constraintAnalysisList.put(constraintRef,
new ConstraintAnalysis<>(constraintRef, constraintWeight, constraintScore, null,
matchCountNode == null ? -1 : Integer.parseInt(matchCountNode.asText())));
} else {
for (var matchNode : constraintNode.get("matches")) {
var matchScore = parseScore(matchNode.get("score").asText());
var justificationNode = matchNode.get("justification");
if (justificationNode == null) {
// Not allowed; if matches are present, they must have justifications.
throw new IllegalStateException("The match justification of constraint (%s)'s match is missing."
.formatted(constraintRef));
}
var justificationString = justificationNode.toString();
if (getConstraintJustificationClass(constraintRef) == null) { // String-based fallback.
var parsedJustification = parseConstraintJustification(constraintRef, justificationString, matchScore);
matchScoreList.add(new MatchAnalysis<>(constraintRef, matchScore, parsedJustification));
} else { // Deserializer-based method.
var parsedJustification =
ctxt.readTreeAsValue(justificationNode, getConstraintJustificationClass(constraintRef));
matchScoreList.add(new MatchAnalysis<>(constraintRef, matchScore, parsedJustification));
}
}
constraintAnalysisList.put(constraintRef,
new ConstraintAnalysis<>(constraintRef, constraintWeight, constraintScore, matchScoreList));
}
}
return new ScoreAnalysis<>(score, constraintAnalysisList, initialized);
}
/**
* The domain is based on a single {@link Score} subtype.
* This method is responsible for parsing the score string into that subtype.
*
* @param scoreString never null
* @return never null
*/
protected abstract Score_ parseScore(String scoreString);
/**
* Each {@link Constraint} in the {@link ConstraintProvider} is justified
* with a custom implementation {@link ConstraintJustification}.
* This method is responsible for telling Jackson which type to serialize the justification into.
* This type must have a deserializer registered.
*
* @param constraintRef never null
* @return null if fallback {@link #parseConstraintJustification(ConstraintRef, String, Score)} should be used instead.
* @param <ConstraintJustification_> Domain-specific custom implementation, typically constraint-specific.
*/
protected <ConstraintJustification_ extends ConstraintJustification> Class<ConstraintJustification_>
getConstraintJustificationClass(ConstraintRef constraintRef) {
return null;
}
/**
* Each {@link Constraint} in the {@link ConstraintProvider} is justified
* with a custom implementation {@link ConstraintJustification}.
* This method is responsible for parsing the justification string into that subtype.
* It is a fallback for when using a deserializer for {@link #getConstraintJustificationClass(ConstraintRef)}
* isn't possible
*
* @param constraintRef never null
* @param constraintJustificationString never null
* @param score never null
* @return never null
* @param <ConstraintJustification_> Domain-specific custom implementation, typically constraint-specific.
*/
protected <ConstraintJustification_ extends ConstraintJustification> ConstraintJustification_
parseConstraintJustification(ConstraintRef constraintRef, String constraintJustificationString, Score_ score) {
throw new UnsupportedOperationException();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/analysis/ScoreAnalysisJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.analysis;
import java.io.IOException;
import java.util.ArrayList;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.analysis.ScoreAnalysis;
import ai.timefold.solver.core.api.score.stream.DefaultConstraintJustification;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class ScoreAnalysisJacksonSerializer<Score_ extends Score<Score_>> extends JsonSerializer<ScoreAnalysis<Score_>> {
@Override
public void serialize(ScoreAnalysis<Score_> value, JsonGenerator gen, SerializerProvider serializers) throws IOException {
gen.writeStartObject();
gen.writeStringField("score", value.score().toString());
gen.writeBooleanField("initialized", value.isSolutionInitialized());
List<Map<String, Object>> result = new ArrayList<>();
value.constraintMap().forEach((constraintRef, constraintAnalysis) -> {
Map<String, Object> constraintAnalysisMap = new LinkedHashMap<>();
constraintAnalysisMap.put("package", constraintRef.packageName());
constraintAnalysisMap.put("name", constraintRef.constraintName());
constraintAnalysisMap.put("weight", constraintAnalysis.weight().toString());
constraintAnalysisMap.put("score", constraintAnalysis.score().toString());
if (constraintAnalysis.matches() != null) {
List<Map<String, Object>> matchAnalysis = new ArrayList<>(constraintAnalysis.matches().size());
constraintAnalysis.matches().forEach(match -> {
Map<String, Object> matchMap = new LinkedHashMap<>();
matchMap.put("score", match.score().toString());
if (match.justification() instanceof DefaultConstraintJustification justification) {
matchMap.put("justification", justification.getFacts());
} else {
matchMap.put("justification", match.justification());
}
matchAnalysis.add(matchMap);
});
constraintAnalysisMap.put("matches", matchAnalysis);
}
if (constraintAnalysis.matchCount() != -1) {
constraintAnalysisMap.put("matchCount", constraintAnalysis.matchCount());
}
result.add(constraintAnalysisMap);
});
gen.writeObjectField("constraints", result);
gen.writeEndObject();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/bendable/BendableScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.bendable;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class BendableScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<BendableScore> {
@Override
public BendableScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return BendableScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/bendable/BendableScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.bendable;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class BendableScoreJacksonSerializer extends AbstractScoreJacksonSerializer<BendableScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/bendablebigdecimal/BendableBigDecimalScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.bendablebigdecimal;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class BendableBigDecimalScoreJacksonDeserializer
extends AbstractScoreJacksonDeserializer<BendableBigDecimalScore> {
@Override
public BendableBigDecimalScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return BendableBigDecimalScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/bendablebigdecimal/BendableBigDecimalScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.bendablebigdecimal;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class BendableBigDecimalScoreJacksonSerializer extends AbstractScoreJacksonSerializer<BendableBigDecimalScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/bendablelong/BendableLongScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.bendablelong;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class BendableLongScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<BendableLongScore> {
@Override
public BendableLongScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return BendableLongScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/bendablelong/BendableLongScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.bendablelong;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class BendableLongScoreJacksonSerializer extends AbstractScoreJacksonSerializer<BendableLongScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardmediumsoft/HardMediumSoftScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardmediumsoft;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class HardMediumSoftScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<HardMediumSoftScore> {
@Override
public HardMediumSoftScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return HardMediumSoftScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardmediumsoft/HardMediumSoftScoreJsonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardmediumsoft;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class HardMediumSoftScoreJsonSerializer extends AbstractScoreJacksonSerializer<HardMediumSoftScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardmediumsoftbigdecimal/HardMediumSoftBigDecimalScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftbigdecimal;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class HardMediumSoftBigDecimalScoreJacksonDeserializer
extends AbstractScoreJacksonDeserializer<HardMediumSoftBigDecimalScore> {
@Override
public HardMediumSoftBigDecimalScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return HardMediumSoftBigDecimalScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardmediumsoftbigdecimal/HardMediumSoftBigDecimalScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftbigdecimal;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class HardMediumSoftBigDecimalScoreJacksonSerializer
extends AbstractScoreJacksonSerializer<HardMediumSoftBigDecimalScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardmediumsoftlong/HardMediumSoftLongScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftlong;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class HardMediumSoftLongScoreJacksonDeserializer
extends AbstractScoreJacksonDeserializer<HardMediumSoftLongScore> {
@Override
public HardMediumSoftLongScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return HardMediumSoftLongScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardmediumsoftlong/HardMediumSoftLongScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardmediumsoftlong;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class HardMediumSoftLongScoreJacksonSerializer extends AbstractScoreJacksonSerializer<HardMediumSoftLongScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardsoft/HardSoftScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardsoft;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class HardSoftScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<HardSoftScore> {
@Override
public HardSoftScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return HardSoftScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardsoft/HardSoftScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardsoft;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class HardSoftScoreJacksonSerializer extends AbstractScoreJacksonSerializer<HardSoftScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardsoftbigdecimal/HardSoftBigDecimalScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardsoftbigdecimal;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class HardSoftBigDecimalScoreJacksonDeserializer
extends AbstractScoreJacksonDeserializer<HardSoftBigDecimalScore> {
@Override
public HardSoftBigDecimalScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return HardSoftBigDecimalScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardsoftbigdecimal/HardSoftBigDecimalScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardsoftbigdecimal;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class HardSoftBigDecimalScoreJacksonSerializer extends AbstractScoreJacksonSerializer<HardSoftBigDecimalScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardsoftlong/HardSoftLongScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardsoftlong;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class HardSoftLongScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<HardSoftLongScore> {
@Override
public HardSoftLongScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return HardSoftLongScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/hardsoftlong/HardSoftLongScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.hardsoftlong;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class HardSoftLongScoreJacksonSerializer extends AbstractScoreJacksonSerializer<HardSoftLongScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/simple/SimpleScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.simple;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class SimpleScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<SimpleScore> {
@Override
public SimpleScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return SimpleScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/simple/SimpleScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.simple;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class SimpleScoreJacksonSerializer extends AbstractScoreJacksonSerializer<SimpleScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/simplebigdecimal/SimpleBigDecimalScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.simplebigdecimal;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class SimpleBigDecimalScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<SimpleBigDecimalScore> {
@Override
public SimpleBigDecimalScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return SimpleBigDecimalScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/simplebigdecimal/SimpleBigDecimalScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.simplebigdecimal;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class SimpleBigDecimalScoreJacksonSerializer extends AbstractScoreJacksonSerializer<SimpleBigDecimalScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/simplelong/SimpleLongScoreJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.buildin.simplelong;
import java.io.IOException;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
public class SimpleLongScoreJacksonDeserializer extends AbstractScoreJacksonDeserializer<SimpleLongScore> {
@Override
public SimpleLongScore deserialize(JsonParser parser, DeserializationContext context) throws IOException {
return SimpleLongScore.parseScore(parser.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/buildin/simplelong/SimpleLongScoreJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.buildin.simplelong;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.jackson.api.score.AbstractScoreJacksonSerializer;
public class SimpleLongScoreJacksonSerializer extends AbstractScoreJacksonSerializer<SimpleLongScore> {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/constraint/ConstraintRefJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.constraint;
import java.io.IOException;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
public final class ConstraintRefJacksonDeserializer extends JsonDeserializer<ConstraintRef> {
@Override
public ConstraintRef deserialize(JsonParser p, DeserializationContext ctxt) throws IOException {
return ConstraintRef.parseId(p.getValueAsString());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/constraint/ConstraintRefJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.constraint;
import java.io.IOException;
import ai.timefold.solver.core.api.score.constraint.ConstraintRef;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class ConstraintRefJacksonSerializer extends JsonSerializer<ConstraintRef> {
@Override
public void serialize(ConstraintRef constraintRef, JsonGenerator generator, SerializerProvider serializers)
throws IOException {
generator.writeString(constraintRef.constraintId());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/BreakJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import ai.timefold.solver.core.api.score.stream.common.Break;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
public final class BreakJacksonDeserializer<Value_, Difference_ extends Comparable<Difference_>>
extends JsonDeserializer<Break<Value_, Difference_>> {
@Override
public Break<Value_, Difference_> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
throws IOException {
JsonNode jsonNode = jsonParser.readValueAsTree();
return deserializationContext.readTreeAsValue(jsonNode, DeserializableBreak.class);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/BreakJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import ai.timefold.solver.core.api.score.stream.common.Break;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class BreakJacksonSerializer<Value_, Difference_ extends Comparable<Difference_>>
extends JsonSerializer<Break<Value_, Difference_>> {
@Override
public void serialize(Break<Value_, Difference_> brk, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider) throws IOException {
jsonGenerator.writeObject(SerializableBreak.of(brk));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/DeserializableBreak.java | package ai.timefold.solver.jackson.api.score.stream.common;
import ai.timefold.solver.core.api.score.stream.common.Break;
import org.jspecify.annotations.NonNull;
import com.fasterxml.jackson.annotation.JsonProperty;
record DeserializableBreak<Value_, Difference_ extends Comparable<Difference_>>(
@JsonProperty("previous_sequence_end") Value_ previousSequenceEnd,
@JsonProperty("next_sequence_start") Value_ nextSequenceStart,
boolean first, boolean last)
implements
Break<Value_, Difference_> {
@Override
public boolean isFirst() {
return first();
}
@Override
public boolean isLast() {
return last();
}
@Override
public @NonNull Value_ getPreviousSequenceEnd() {
return previousSequenceEnd();
}
@Override
public @NonNull Value_ getNextSequenceStart() {
return nextSequenceStart();
}
@Override
public @NonNull Difference_ getLength() {
/*
* Difference_ is a custom type, hidden deep within the object tree.
* Allowing for deserialization of this would have significantly complicated the code,
* and put extra burdens on the user.
* This way, deserialization can happen out-of-the-box,
* and the information can still be computed on the user side.
*/
throw new UnsupportedOperationException("""
Deserialized %s does not carry length information.
It can be computed from the endpoints."""
.formatted(getClass().getSimpleName()));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/DeserializableLoadBalance.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.math.BigDecimal;
import java.util.Map;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import org.jspecify.annotations.NonNull;
record DeserializableLoadBalance<Value_>(BigDecimal unfairness) implements LoadBalance<Value_> {
@Override
public @NonNull Map<Value_, Long> loads() {
throw new UnsupportedOperationException("Deserialization of loads is not supported.");
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/DeserializableSequence.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.util.Collection;
import java.util.List;
import ai.timefold.solver.core.api.score.stream.common.Break;
import ai.timefold.solver.core.api.score.stream.common.Sequence;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
import com.fasterxml.jackson.annotation.JsonProperty;
record DeserializableSequence<Value_, Difference_ extends Comparable<Difference_>>(
@JsonProperty("previous_break") DeserializableBreak<Value_, Difference_> previousBreak,
@JsonProperty("next_break") DeserializableBreak<Value_, Difference_> nextBreak,
boolean first, boolean last, List<Value_> items)
implements
Sequence<Value_, Difference_> {
@Override
public @NonNull Value_ getFirstItem() {
return items.get(0);
}
@Override
public @NonNull Value_ getLastItem() {
return items.get(items.size() - 1);
}
@Override
public boolean isFirst() {
return first();
}
@Override
public boolean isLast() {
return last();
}
@Override
public @Nullable Break<Value_, Difference_> getPreviousBreak() {
return previousBreak();
}
@Override
public @Nullable Break<Value_, Difference_> getNextBreak() {
return nextBreak();
}
@Override
public @NonNull Collection<Value_> getItems() {
return items();
}
@Override
public int getCount() {
return items.size();
}
@Override
public @NonNull Difference_ getLength() {
/*
* Difference_ is a custom type, hidden deep within the object tree.
* Allowing for deserialization of this would have significantly complicated the code,
* and put extra burdens on the user.
* This way, deserialization can happen out-of-the-box,
* and the information can still be computed on the user side.
*/
throw new UnsupportedOperationException("""
Deserialized %s does not carry length information.
It can be computed from the items."""
.formatted(Sequence.class.getSimpleName()));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/DeserializableSequenceChain.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.util.Collection;
import java.util.Collections;
import java.util.List;
import ai.timefold.solver.core.api.score.stream.common.Break;
import ai.timefold.solver.core.api.score.stream.common.Sequence;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import org.jspecify.annotations.NonNull;
import org.jspecify.annotations.Nullable;
record DeserializableSequenceChain<Value_, Difference_ extends Comparable<Difference_>>(
List<DeserializableSequence<Value_, Difference_>> sequences)
implements
SequenceChain<Value_, Difference_> {
@Override
public @NonNull Collection<Sequence<Value_, Difference_>> getConsecutiveSequences() {
return Collections.unmodifiableCollection(sequences());
}
@Override
public @NonNull Collection<Break<Value_, Difference_>> getBreaks() {
throw new UnsupportedOperationException("""
Deserialized %s does not carry break information.
It can be computed from the sequences."""
.formatted(getClass().getSimpleName()));
}
@Override
public @Nullable Sequence<Value_, Difference_> getFirstSequence() {
return sequences().get(0);
}
@Override
public @Nullable Sequence<Value_, Difference_> getLastSequence() {
return sequences().get(sequences().size() - 1);
}
@Override
public @Nullable Break<Value_, Difference_> getFirstBreak() {
throw new UnsupportedOperationException("""
Deserialized %s does not carry break information.
It can be computed from the sequences."""
.formatted(getClass().getSimpleName()));
}
@Override
public @Nullable Break<Value_, Difference_> getLastBreak() {
throw new UnsupportedOperationException("""
Deserialized %s does not carry break information.
It can be computed from the sequences."""
.formatted(getClass().getSimpleName()));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/LoadBalanceJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
public final class LoadBalanceJacksonDeserializer<Value_>
extends JsonDeserializer<LoadBalance<Value_>> {
@Override
public LoadBalance<Value_> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
throws IOException {
JsonNode jsonNode = jsonParser.readValueAsTree();
return deserializationContext.readTreeAsValue(jsonNode, DeserializableLoadBalance.class);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/LoadBalanceJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class LoadBalanceJacksonSerializer<Value_>
extends JsonSerializer<LoadBalance<Value_>> {
@Override
public void serialize(LoadBalance<Value_> loadBalance, JsonGenerator jsonGenerator, SerializerProvider serializers)
throws IOException {
jsonGenerator.writeObject(SerializableLoadBalance.of(loadBalance));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SequenceChainJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
public final class SequenceChainJacksonDeserializer<Value_, Difference_ extends Comparable<Difference_>>
extends JsonDeserializer<SequenceChain<Value_, Difference_>> {
@Override
public SequenceChain<Value_, Difference_> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
throws IOException {
JsonNode jsonNode = jsonParser.readValueAsTree();
return deserializationContext.readTreeAsValue(jsonNode, DeserializableSequenceChain.class);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SequenceChainJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
import ai.timefold.solver.core.api.score.stream.common.SequenceChain;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class SequenceChainJacksonSerializer<Value_, Difference_ extends Comparable<Difference_>>
extends JsonSerializer<SequenceChain<Value_, Difference_>> {
@Override
public void serialize(SequenceChain<Value_, Difference_> sequenceChain, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider) throws IOException {
var serializedSequenceList =
new ArrayList<SerializableSequence<Value_>>(sequenceChain.getConsecutiveSequences().size());
for (var sequence : sequenceChain.getConsecutiveSequences()) {
var serializedSequence =
new SerializableSequence<>(sequence.isFirst(), sequence.isLast(), List.copyOf(sequence.getItems()));
serializedSequenceList.add(serializedSequence);
}
jsonGenerator.writeObject(new SerializableSequenceChain<>(serializedSequenceList));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SequenceJacksonDeserializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import ai.timefold.solver.core.api.score.stream.common.Sequence;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
public final class SequenceJacksonDeserializer<Value_, Difference_ extends Comparable<Difference_>>
extends JsonDeserializer<Sequence<Value_, Difference_>> {
@Override
public Sequence<Value_, Difference_> deserialize(JsonParser jsonParser, DeserializationContext deserializationContext)
throws IOException {
JsonNode jsonNode = jsonParser.readValueAsTree();
return deserializationContext.readTreeAsValue(jsonNode, DeserializableSequence.class);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SequenceJacksonSerializer.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.io.IOException;
import java.util.List;
import ai.timefold.solver.core.api.score.stream.common.Sequence;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class SequenceJacksonSerializer<Value_, Difference_ extends Comparable<Difference_>>
extends JsonSerializer<Sequence<Value_, Difference_>> {
@Override
public void serialize(Sequence<Value_, Difference_> sequence, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider) throws IOException {
jsonGenerator.writeObject(
new SerializableSequence<>(
SerializableBreak.of(sequence.getPreviousBreak()),
SerializableBreak.of(sequence.getNextBreak()),
List.copyOf(sequence.getItems())));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SerializableBreak.java | package ai.timefold.solver.jackson.api.score.stream.common;
import ai.timefold.solver.core.api.score.stream.common.Break;
import com.fasterxml.jackson.annotation.JsonProperty;
record SerializableBreak<Value_>(
@JsonProperty("previous_sequence_end") Value_ previousSequenceEnd,
@JsonProperty("next_sequence_start") Value_ nextSequenceStart,
boolean first, boolean last) {
static <Value_> SerializableBreak<Value_> of(Break<Value_, ?> brk) {
if (brk == null) {
return null;
}
return new SerializableBreak<>(brk.getPreviousSequenceEnd(), brk.getNextSequenceStart(), brk.isFirst(), brk.isLast());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SerializableLoadBalance.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.math.BigDecimal;
import java.util.Objects;
import ai.timefold.solver.core.api.score.stream.common.LoadBalance;
record SerializableLoadBalance(BigDecimal unfairness) {
SerializableLoadBalance(BigDecimal unfairness) {
this.unfairness = Objects.requireNonNull(unfairness);
}
static <Value_> SerializableLoadBalance of(LoadBalance<Value_> loadBalance) {
if (loadBalance == null) {
return null;
}
// We do not serialize loads(), because:
// - It's possibly a very large map, that would end up in the JSON through default justifications.
// - Deserializing the map would be tricky, because the type of <Value_> is not known at runtime.
return new SerializableLoadBalance(loadBalance.unfairness());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SerializableSequence.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.util.List;
import com.fasterxml.jackson.annotation.JsonProperty;
record SerializableSequence<Value_>(
@JsonProperty("previous_break") SerializableBreak<Value_> previousBreak,
@JsonProperty("next_break") SerializableBreak<Value_> nextBreak,
boolean first, boolean last, List<Value_> items) {
public SerializableSequence(SerializableBreak<Value_> previousBreak, SerializableBreak<Value_> nextBreak,
List<Value_> items) {
this(previousBreak, nextBreak, previousBreak == null, nextBreak == null, items);
}
public SerializableSequence(boolean first, boolean last, List<Value_> items) {
this(null, null, first, last, items);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/SerializableSequenceChain.java | package ai.timefold.solver.jackson.api.score.stream.common;
import java.util.List;
record SerializableSequenceChain<Value_>(List<SerializableSequence<Value_>> sequences) {
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/score/stream/common/package-info.java | /**
* Includes support for deserialization of constraint collector models,
* specifically {@link ai.timefold.solver.core.api.score.stream.common.SequenceChain},
* {@link ai.timefold.solver.core.api.score.stream.common.Sequence},
* {@link ai.timefold.solver.core.api.score.stream.common.Break}
* and {@link ai.timefold.solver.core.api.score.stream.common.LoadBalance}.
* These can be exposed in {@link ai.timefold.solver.core.api.score.analysis.ScoreAnalysis}
* through user-specified {@link ai.timefold.solver.core.api.score.stream.ConstraintJustification}.
* The serialization and deserialization of these types happens automatically,
* if the user has registered {@link ai.timefold.solver.jackson.api.TimefoldJacksonModule}
* with their {@link com.fasterxml.jackson.databind.ObjectMapper}.
*
* <p>
* Sequences carry user-specified types of values and for this to work,
* these values need to be serializable and deserializable.
* The user is responsible for ensuring this,
* as they are user types and we do not know how to serialize or deserialize them.
* For minimal JSON output to be produced,
* and for reference integrity to be maintained,
* it is recommended that the user types handle their identity properly through
* {@link com.fasterxml.jackson.annotation.JsonIdentityInfo}
*
* <p>
* The implementation converts {@link ai.timefold.solver.core.api.score.stream.common.Sequence} instances
* to {@link ai.timefold.solver.jackson.api.score.stream.common.SerializableSequence} instances,
* which can then be directly serialized.
* During deserialization,
* the implementation first reads {@link ai.timefold.solver.jackson.api.score.stream.common.SerializableSequence} instances
* and then converts them to {@link ai.timefold.solver.jackson.api.score.stream.common.DeserializableSequence} instances,
* which are returned to the user.
* It is only the latter that implements {@link ai.timefold.solver.core.api.score.stream.common.Sequence},
* as otherwise an endless loop would occur during serialization.
* We never create instances of the original Sequence-implementing class from solver-core,
* as those require much more than just the pure data.
*
* <p>
* For {@link ai.timefold.solver.core.api.score.stream.common.Sequence} instances
* and for the entire {@link ai.timefold.solver.core.api.score.stream.common.SequenceChain},
* we follow the same pattern.
* {@link ai.timefold.solver.core.api.score.stream.common.Break} instances are only serialized
* when {@link ai.timefold.solver.core.api.score.stream.common.Sequence} is being serialized directly.
* When {@link ai.timefold.solver.core.api.score.stream.common.SequenceChain} is being serialized,
* {@link ai.timefold.solver.core.api.score.stream.common.Break} instances between sequences are not included,
* but the JSON has been designed in such a way that this can later be added in a backwards compatible manner.
*
* <p>
* {@link ai.timefold.solver.core.api.score.stream.common.Break#getLength() Break length} is not available after
* deserialization,
* as it would require the user to specify a custom deserializer for the custom Difference_ type
* and would have considerably complicated the entire deserialization process.
* Since the user can easily compute the length from the endpoints,
* we decided to avoid the overhead.
* The same deserialization treatment is applied to {@link ai.timefold.solver.core.api.score.stream.common.SequenceChain}.
*/
package ai.timefold.solver.jackson.api.score.stream.common; |
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/solver/AbstractRecommendedAssignmentJacksonDeserializer.java | package ai.timefold.solver.jackson.api.solver;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.analysis.ScoreAnalysis;
import ai.timefold.solver.core.api.solver.RecommendedAssignment;
import ai.timefold.solver.core.impl.solver.DefaultRecommendedAssignment;
import ai.timefold.solver.jackson.api.score.analysis.AbstractScoreAnalysisJacksonDeserializer;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
* Extend this to implement {@link RecommendedAssignment} deserialization specific for your domain.
* Make sure to also:
*
* <ul>
* <li>extend {@link AbstractScoreAnalysisJacksonDeserializer},</li>
* <li>provide deserializer for {@link AbstractRecommendedAssignmentJacksonDeserializer#getPropositionClass()}</li>
* <li>and finally add all of these to the Jackson {@link ObjectMapper}.</li>
* </ul>
*
* @param <Score_>
*/
public abstract class AbstractRecommendedAssignmentJacksonDeserializer<Proposition_, Score_ extends Score<Score_>>
extends JsonDeserializer<RecommendedAssignment<Proposition_, Score_>> {
/**
* {@link DefaultRecommendedAssignment} requires ID for purposes of ordering,
* to break ties if two instances have the same score.
* This ID has no other effect on the instances.
*
* <p>
* This counter is used to generate an ever-increasing ID.
*/
private final AtomicLong ID_COUNTER = new AtomicLong(0L);
@Override
public final RecommendedAssignment<Proposition_, Score_> deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException {
JsonNode node = p.readValueAsTree();
Proposition_ proposition = ctxt.readTreeAsValue(node.get("proposition"), getPropositionClass());
ScoreAnalysis<Score_> diff = ctxt.readTreeAsValue(node.get("scoreDiff"), ScoreAnalysis.class);
return new DefaultRecommendedAssignment<>(ID_COUNTER.getAndIncrement(), proposition, diff);
}
/**
* Each {@link RecommendedAssignment} has a proposition, which is a custom object returned by the user.
* It is therefore the user and only the user who can deserialize the proposition.
* This type must have a deserializer registered.
*
* @return never null
*/
protected abstract Class<Proposition_> getPropositionClass();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/solver/AbstractRecommendedFitJacksonDeserializer.java | package ai.timefold.solver.jackson.api.solver;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;
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;
import ai.timefold.solver.core.impl.solver.DefaultRecommendedFit;
import com.fasterxml.jackson.core.JsonParser;
import com.fasterxml.jackson.databind.DeserializationContext;
import com.fasterxml.jackson.databind.JsonDeserializer;
import com.fasterxml.jackson.databind.JsonNode;
/**
* @deprecated Prefer to use the {@link AbstractRecommendedAssignmentJacksonDeserializer} instead.
*/
@Deprecated(forRemoval = true, since = "1.15.0")
public abstract class AbstractRecommendedFitJacksonDeserializer<Proposition_, Score_ extends Score<Score_>>
extends JsonDeserializer<RecommendedFit<Proposition_, Score_>> {
/**
* {@link DefaultRecommendedFit} requires ID for purposes of ordering,
* to break ties if two instances have the same score.
* This ID has no other effect on the instances.
*
* <p>
* This counter is used to generate an ever-increasing ID.
*/
private final AtomicLong ID_COUNTER = new AtomicLong(0L);
@Override
public final RecommendedFit<Proposition_, Score_> deserialize(JsonParser p, DeserializationContext ctxt)
throws IOException {
JsonNode node = p.readValueAsTree();
Proposition_ proposition = ctxt.readTreeAsValue(node.get("proposition"), getPropositionClass());
ScoreAnalysis<Score_> diff = ctxt.readTreeAsValue(node.get("scoreDiff"), ScoreAnalysis.class);
return new DefaultRecommendedFit<>(ID_COUNTER.getAndIncrement(), proposition, diff);
}
/**
* Each {@link RecommendedFit} has a proposition, which is a custom object returned by the user.
* It is therefore the user and only the user who can deserialize the proposition.
* This type must have a deserializer registered.
*
* @return never null
*/
protected abstract Class<Proposition_> getPropositionClass();
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/solver/RecommendedAssignmentJacksonSerializer.java | package ai.timefold.solver.jackson.api.solver;
import java.io.IOException;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.solver.RecommendedAssignment;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class RecommendedAssignmentJacksonSerializer<Proposition_, Score_ extends Score<Score_>>
extends JsonSerializer<RecommendedAssignment<Proposition_, Score_>> {
@Override
public void serialize(RecommendedAssignment<Proposition_, Score_> value, JsonGenerator gen,
SerializerProvider serializerProvider) throws IOException {
gen.writeStartObject();
gen.writeObjectField("proposition", value.proposition());
gen.writeObjectField("scoreDiff", value.scoreAnalysisDiff());
gen.writeEndObject();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/api/solver/RecommendedFitJacksonSerializer.java | package ai.timefold.solver.jackson.api.solver;
import java.io.IOException;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.solver.RecommendedFit;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
/**
* @deprecated Prefer to use the {@link RecommendedAssignmentJacksonSerializer} instead.
*/
@Deprecated(forRemoval = true, since = "1.15.0")
public final class RecommendedFitJacksonSerializer<Proposition_, Score_ extends Score<Score_>>
extends JsonSerializer<RecommendedFit<Proposition_, Score_>> {
@Override
public void serialize(RecommendedFit<Proposition_, Score_> value, JsonGenerator gen, SerializerProvider serializerProvider)
throws IOException {
gen.writeStartObject();
gen.writeObjectField("proposition", value.proposition());
gen.writeObjectField("scoreDiff", value.scoreAnalysisDiff());
gen.writeEndObject();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/impl/domain | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/impl/domain/solution/JacksonSolutionFileIO.java | package ai.timefold.solver.jackson.impl.domain.solution;
import java.io.File;
import java.io.IOException;
import java.io.InputStream;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.persistence.common.api.domain.solution.SolutionFileIO;
import com.fasterxml.jackson.databind.ObjectMapper;
/**
*
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class JacksonSolutionFileIO<Solution_> implements SolutionFileIO<Solution_> {
private final Class<Solution_> clazz;
private final ObjectMapper mapper;
public JacksonSolutionFileIO(Class<Solution_> clazz) {
this(clazz, new ObjectMapper());
}
public JacksonSolutionFileIO(Class<Solution_> clazz, ObjectMapper mapper) {
this.clazz = clazz;
this.mapper = mapper;
// Loads TimefoldJacksonModule via ServiceLoader, as well as any other Jackson modules on the classpath.
mapper.findAndRegisterModules();
}
@Override
public String getInputFileExtension() {
return "json";
}
@Override
public String getOutputFileExtension() {
return "json";
}
@Override
public Solution_ read(File inputSolutionFile) {
try {
return mapper.readValue(inputSolutionFile, clazz);
} catch (IOException e) {
throw new IllegalArgumentException("Failed reading inputSolutionFile (" + inputSolutionFile + ").", e);
}
}
public Solution_ read(InputStream inputSolutionStream) {
try {
return mapper.readValue(inputSolutionStream, clazz);
} catch (IOException e) {
throw new IllegalArgumentException("Failed reading inputSolutionStream.", e);
}
}
@Override
public void write(Solution_ solution, File file) {
try {
mapper.writerWithDefaultPrettyPrinter().writeValue(file, solution);
} catch (IOException e) {
throw new IllegalArgumentException("Failed write", e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution/diff/PlanningEntityDiffJacksonSerializer.java | package ai.timefold.solver.jackson.preview.api.domain.solution.diff;
import java.io.IOException;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningEntityDiff;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class PlanningEntityDiffJacksonSerializer<Solution_, Entity_>
extends JsonSerializer<PlanningEntityDiff<Solution_, Entity_>> {
@Override
public void serialize(PlanningEntityDiff<Solution_, Entity_> entityDiff, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider) throws IOException {
jsonGenerator.writeObject(SerializablePlanningEntityDiff.of(entityDiff));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution/diff/PlanningSolutionDiffJacksonSerializer.java | package ai.timefold.solver.jackson.preview.api.domain.solution.diff;
import java.io.IOException;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningSolutionDiff;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class PlanningSolutionDiffJacksonSerializer<Solution_>
extends JsonSerializer<PlanningSolutionDiff<Solution_>> {
@Override
public void serialize(PlanningSolutionDiff<Solution_> solutionDiff, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider) throws IOException {
jsonGenerator.writeObject(SerializablePlanningSolutionDiff.of(solutionDiff));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution/diff/PlanningVariableDiffJacksonSerializer.java | package ai.timefold.solver.jackson.preview.api.domain.solution.diff;
import java.io.IOException;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningVariableDiff;
import com.fasterxml.jackson.core.JsonGenerator;
import com.fasterxml.jackson.databind.JsonSerializer;
import com.fasterxml.jackson.databind.SerializerProvider;
public final class PlanningVariableDiffJacksonSerializer<Solution_, Entity_, Value_>
extends JsonSerializer<PlanningVariableDiff<Solution_, Entity_, Value_>> {
@Override
public void serialize(PlanningVariableDiff<Solution_, Entity_, Value_> variableDiff, JsonGenerator jsonGenerator,
SerializerProvider serializerProvider) throws IOException {
jsonGenerator.writeObject(SerializablePlanningVariableDiff.of(variableDiff));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution/diff/SerializablePlanningEntityDiff.java | package ai.timefold.solver.jackson.preview.api.domain.solution.diff;
import java.util.Collection;
import java.util.stream.Collectors;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningEntityDiff;
import com.fasterxml.jackson.annotation.JsonProperty;
record SerializablePlanningEntityDiff<Entity_>(
@JsonProperty("entity_class") String entityClass,
@JsonProperty("entity") Entity_ entity,
@JsonProperty("variable_diffs") Collection<SerializablePlanningVariableDiff<?>> variableDiffs) {
public static <Entity_> SerializablePlanningEntityDiff<Entity_> of(PlanningEntityDiff<?, Entity_> diff) {
return new SerializablePlanningEntityDiff<>(
diff.entity().getClass().getCanonicalName(),
diff.entity(),
diff.variableDiffs().stream()
.map(SerializablePlanningVariableDiff::of)
.collect(Collectors.toList()));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution/diff/SerializablePlanningSolutionDiff.java | package ai.timefold.solver.jackson.preview.api.domain.solution.diff;
import java.util.Collection;
import java.util.stream.Collectors;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningSolutionDiff;
import com.fasterxml.jackson.annotation.JsonProperty;
record SerializablePlanningSolutionDiff(
@JsonProperty("removed_entities") Collection<Object> removedEntities,
@JsonProperty("added_entities") Collection<Object> addedEntities,
@JsonProperty("entity_diffs") Collection<SerializablePlanningEntityDiff<?>> entityDiffs) {
public static <Solution_> SerializablePlanningSolutionDiff of(PlanningSolutionDiff<Solution_> diff) {
return new SerializablePlanningSolutionDiff(
diff.removedEntities(),
diff.addedEntities(),
diff.entityDiffs().stream()
.map(SerializablePlanningEntityDiff::of)
.collect(Collectors.toList()));
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution/diff/SerializablePlanningVariableDiff.java | package ai.timefold.solver.jackson.preview.api.domain.solution.diff;
import ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningVariableDiff;
import com.fasterxml.jackson.annotation.JsonProperty;
record SerializablePlanningVariableDiff<Value_>(
@JsonProperty("name") String variableName,
@JsonProperty("old_value") Value_ oldValue,
@JsonProperty("new_value") Value_ newValue) {
public static <Value_> SerializablePlanningVariableDiff<Value_> of(PlanningVariableDiff<?, ?, Value_> diff) {
return new SerializablePlanningVariableDiff<>(
diff.variableMetaModel().name(),
diff.oldValue(),
diff.newValue());
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution | java-sources/ai/timefold/solver/timefold-solver-jackson/1.26.1/ai/timefold/solver/jackson/preview/api/domain/solution/diff/package-info.java | /**
* Includes support for deserialization of
* {@link ai.timefold.solver.core.preview.api.domain.solution.diff.PlanningSolutionDiff}.
* The serialization happens automatically,
* if the user has registered {@link ai.timefold.solver.jackson.api.TimefoldJacksonModule}
* with their {@link com.fasterxml.jackson.databind.ObjectMapper}.
*
* <p>
* Deserialization is not implemented, on account of losing the information about the type of the solution,
* its entities and values.
*/
package ai.timefold.solver.jackson.preview.api.domain.solution.diff; |
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/AbstractScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score;
import jakarta.xml.bind.annotation.adapters.XmlAdapter;
import ai.timefold.solver.core.api.score.Score;
/**
* JAXB binding support for a {@link Score} type.
* <p>
* For example: use {@code @XmlJavaTypeAdapter(HardSoftScoreJaxbAdapter.class)}
* on a {@code HardSoftScore score} field and it will marshalled to XML as {@code <score>-999hard/-999soft</score>}.
*
* @see Score
* @param <Score_> the actual score type
*/
public abstract class AbstractScoreJaxbAdapter<Score_ extends Score<Score_>> extends XmlAdapter<String, Score_> {
@Override
public String marshal(Score_ score) {
return score.toString();
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/PolymorphicScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score;
import jakarta.xml.bind.annotation.XmlAttribute;
import jakarta.xml.bind.annotation.XmlValue;
import jakarta.xml.bind.annotation.adapters.XmlAdapter;
import ai.timefold.solver.core.api.score.Score;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
public class PolymorphicScoreJaxbAdapter extends XmlAdapter<PolymorphicScoreJaxbAdapter.JaxbAdaptedScore, Score> {
@Override
public Score unmarshal(JaxbAdaptedScore jaxbAdaptedScore) {
if (jaxbAdaptedScore == null) {
return null;
}
String scoreClassName = jaxbAdaptedScore.scoreClassName;
String scoreString = jaxbAdaptedScore.scoreString;
// TODO Can this delegate to ScoreUtils.parseScore()?
if (scoreClassName.equals(SimpleScore.class.getName())) {
return SimpleScore.parseScore(scoreString);
} else if (scoreClassName.equals(SimpleLongScore.class.getName())) {
return SimpleLongScore.parseScore(scoreString);
} else if (scoreClassName.equals(SimpleBigDecimalScore.class.getName())) {
return SimpleBigDecimalScore.parseScore(scoreString);
} else if (scoreClassName.equals(HardSoftScore.class.getName())) {
return HardSoftScore.parseScore(scoreString);
} else if (scoreClassName.equals(HardSoftLongScore.class.getName())) {
return HardSoftLongScore.parseScore(scoreString);
} else if (scoreClassName.equals(HardSoftBigDecimalScore.class.getName())) {
return HardSoftBigDecimalScore.parseScore(scoreString);
} else if (scoreClassName.equals(HardMediumSoftScore.class.getName())) {
return HardMediumSoftScore.parseScore(scoreString);
} else if (scoreClassName.equals(HardMediumSoftLongScore.class.getName())) {
return HardMediumSoftLongScore.parseScore(scoreString);
} else if (scoreClassName.equals(HardMediumSoftBigDecimalScore.class.getName())) {
return HardMediumSoftBigDecimalScore.parseScore(scoreString);
} else if (scoreClassName.equals(BendableScore.class.getName())) {
return BendableScore.parseScore(scoreString);
} else if (scoreClassName.equals(BendableLongScore.class.getName())) {
return BendableLongScore.parseScore(scoreString);
} else if (scoreClassName.equals(BendableBigDecimalScore.class.getName())) {
return BendableBigDecimalScore.parseScore(scoreString);
} else {
throw new IllegalArgumentException("Unrecognized scoreClassName (" + scoreClassName
+ ") for scoreString (" + scoreString + ").");
}
}
@Override
public JaxbAdaptedScore marshal(Score score) {
if (score == null) {
return null;
}
return new JaxbAdaptedScore(score);
}
static class JaxbAdaptedScore {
@XmlAttribute(name = "class")
private String scoreClassName;
@XmlValue
private String scoreString;
private JaxbAdaptedScore() {
// Required by JAXB
}
public JaxbAdaptedScore(Score score) {
this.scoreClassName = score.getClass().getName();
this.scoreString = score.toString();
}
String getScoreClassName() {
return scoreClassName;
}
String getScoreString() {
return scoreString;
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/package-info.java |
/**
* JAXB bindings for {@link ai.timefold.solver.core.api.score.Score}.
*/
package ai.timefold.solver.jaxb.api.score;
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/bendable/BendableScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.bendable;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class BendableScoreJaxbAdapter extends AbstractScoreJaxbAdapter<BendableScore> {
@Override
public BendableScore unmarshal(String scoreString) {
return BendableScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/bendablebigdecimal/BendableBigDecimalScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.bendablebigdecimal;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class BendableBigDecimalScoreJaxbAdapter extends AbstractScoreJaxbAdapter<BendableBigDecimalScore> {
@Override
public BendableBigDecimalScore unmarshal(String scoreString) {
return BendableBigDecimalScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/bendablelong/BendableLongScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.bendablelong;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class BendableLongScoreJaxbAdapter extends AbstractScoreJaxbAdapter<BendableLongScore> {
@Override
public BendableLongScore unmarshal(String scoreString) {
return BendableLongScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/hardmediumsoft/HardMediumSoftScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.hardmediumsoft;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class HardMediumSoftScoreJaxbAdapter extends AbstractScoreJaxbAdapter<HardMediumSoftScore> {
@Override
public HardMediumSoftScore unmarshal(String scoreString) {
return HardMediumSoftScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/hardmediumsoftbigdecimal/HardMediumSoftBigDecimalScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.hardmediumsoftbigdecimal;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class HardMediumSoftBigDecimalScoreJaxbAdapter extends AbstractScoreJaxbAdapter<HardMediumSoftBigDecimalScore> {
@Override
public HardMediumSoftBigDecimalScore unmarshal(String scoreString) {
return HardMediumSoftBigDecimalScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/hardmediumsoftlong/HardMediumSoftLongScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.hardmediumsoftlong;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class HardMediumSoftLongScoreJaxbAdapter extends AbstractScoreJaxbAdapter<HardMediumSoftLongScore> {
@Override
public HardMediumSoftLongScore unmarshal(String scoreString) {
return HardMediumSoftLongScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/hardsoft/HardSoftScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.hardsoft;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class HardSoftScoreJaxbAdapter extends AbstractScoreJaxbAdapter<HardSoftScore> {
@Override
public HardSoftScore unmarshal(String scoreString) {
return HardSoftScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/hardsoftbigdecimal/HardSoftBigDecimalScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.hardsoftbigdecimal;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class HardSoftBigDecimalScoreJaxbAdapter extends AbstractScoreJaxbAdapter<HardSoftBigDecimalScore> {
@Override
public HardSoftBigDecimalScore unmarshal(String scoreString) {
return HardSoftBigDecimalScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/hardsoftlong/HardSoftLongScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.hardsoftlong;
import ai.timefold.solver.core.api.score.buildin.hardsoftlong.HardSoftLongScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class HardSoftLongScoreJaxbAdapter extends AbstractScoreJaxbAdapter<HardSoftLongScore> {
@Override
public HardSoftLongScore unmarshal(String scoreString) {
return HardSoftLongScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/simple/SimpleScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.simple;
import ai.timefold.solver.core.api.score.buildin.simple.SimpleScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class SimpleScoreJaxbAdapter extends AbstractScoreJaxbAdapter<SimpleScore> {
@Override
public SimpleScore unmarshal(String scoreString) {
return SimpleScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/simplebigdecimal/SimpleBigDecimalScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.simplebigdecimal;
import ai.timefold.solver.core.api.score.buildin.simplebigdecimal.SimpleBigDecimalScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class SimpleBigDecimalScoreJaxbAdapter extends AbstractScoreJaxbAdapter<SimpleBigDecimalScore> {
@Override
public SimpleBigDecimalScore unmarshal(String scoreString) {
return SimpleBigDecimalScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/api/score/buildin/simplelong/SimpleLongScoreJaxbAdapter.java | package ai.timefold.solver.jaxb.api.score.buildin.simplelong;
import ai.timefold.solver.core.api.score.buildin.simplelong.SimpleLongScore;
import ai.timefold.solver.jaxb.api.score.AbstractScoreJaxbAdapter;
public class SimpleLongScoreJaxbAdapter extends AbstractScoreJaxbAdapter<SimpleLongScore> {
@Override
public SimpleLongScore unmarshal(String scoreString) {
return SimpleLongScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/impl/domain | java-sources/ai/timefold/solver/timefold-solver-jaxb/1.26.1/ai/timefold/solver/jaxb/impl/domain/solution/JaxbSolutionFileIO.java | package ai.timefold.solver.jaxb.impl.domain.solution;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.OutputStreamWriter;
import java.io.Reader;
import java.io.Writer;
import java.util.Arrays;
import jakarta.xml.bind.JAXBContext;
import jakarta.xml.bind.JAXBException;
import jakarta.xml.bind.Marshaller;
import jakarta.xml.bind.Unmarshaller;
import ai.timefold.solver.core.api.domain.solution.PlanningSolution;
import ai.timefold.solver.persistence.common.api.domain.solution.SolutionFileIO;
/**
* @param <Solution_> the solution type, the class with the {@link PlanningSolution} annotation
*/
public class JaxbSolutionFileIO<Solution_> implements SolutionFileIO<Solution_> {
private final Marshaller marshaller;
private final Unmarshaller unmarshaller;
public JaxbSolutionFileIO(Class... jaxbAnnotatedClasses) {
try {
JAXBContext jaxbContext = JAXBContext.newInstance(jaxbAnnotatedClasses);
marshaller = jaxbContext.createMarshaller();
marshaller.setProperty(Marshaller.JAXB_FORMATTED_OUTPUT, true);
unmarshaller = jaxbContext.createUnmarshaller();
} catch (JAXBException e) {
throw new IllegalArgumentException("JAXB creation for classes (" + Arrays.toString(jaxbAnnotatedClasses)
+ ") has failed.", e);
}
}
@Override
public String getInputFileExtension() {
return "xml";
}
@Override
public Solution_ read(File inputSolutionFile) {
try (Reader reader = new InputStreamReader(new FileInputStream(inputSolutionFile), "UTF-8")) {
return (Solution_) unmarshaller.unmarshal(reader);
} catch (IOException | JAXBException e) {
throw new IllegalArgumentException("Failed reading inputSolutionFile (" + inputSolutionFile + ").", e);
}
}
@Override
public void write(Solution_ solution, File outputSolutionFile) {
try (Writer writer = new OutputStreamWriter(new FileOutputStream(outputSolutionFile), "UTF-8")) {
marshaller.marshal(solution, writer);
} catch (IOException | JAXBException e) {
throw new IllegalArgumentException("Failed writing outputSolutionFile (" + outputSolutionFile + ").", e);
}
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/bendable/BendableScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.bendable;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.bendable.BendableScore;
@Converter
public class BendableScoreConverter implements AttributeConverter<BendableScore, String> {
@Override
public String convertToDatabaseColumn(BendableScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public BendableScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return BendableScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/bendablebigdecimal/BendableBigDecimalScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.bendablebigdecimal;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.bendablebigdecimal.BendableBigDecimalScore;
@Converter
public class BendableBigDecimalScoreConverter implements AttributeConverter<BendableBigDecimalScore, String> {
@Override
public String convertToDatabaseColumn(BendableBigDecimalScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public BendableBigDecimalScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return BendableBigDecimalScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/bendablelong/BendableLongScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.bendablelong;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.bendablelong.BendableLongScore;
@Converter
public class BendableLongScoreConverter implements AttributeConverter<BendableLongScore, String> {
@Override
public String convertToDatabaseColumn(BendableLongScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public BendableLongScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return BendableLongScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/hardmediumsoft/HardMediumSoftScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.hardmediumsoft;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoft.HardMediumSoftScore;
@Converter
public class HardMediumSoftScoreConverter implements AttributeConverter<HardMediumSoftScore, String> {
@Override
public String convertToDatabaseColumn(HardMediumSoftScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public HardMediumSoftScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return HardMediumSoftScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/hardmediumsoftbigdecimal/HardMediumSoftBigDecimalScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.hardmediumsoftbigdecimal;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftbigdecimal.HardMediumSoftBigDecimalScore;
@Converter
public class HardMediumSoftBigDecimalScoreConverter implements AttributeConverter<HardMediumSoftBigDecimalScore, String> {
@Override
public String convertToDatabaseColumn(HardMediumSoftBigDecimalScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public HardMediumSoftBigDecimalScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return HardMediumSoftBigDecimalScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/hardmediumsoftlong/HardMediumSoftLongScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.hardmediumsoftlong;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.hardmediumsoftlong.HardMediumSoftLongScore;
@Converter
public class HardMediumSoftLongScoreConverter implements AttributeConverter<HardMediumSoftLongScore, String> {
@Override
public String convertToDatabaseColumn(HardMediumSoftLongScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public HardMediumSoftLongScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return HardMediumSoftLongScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/hardsoft/HardSoftScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.hardsoft;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.hardsoft.HardSoftScore;
@Converter
public class HardSoftScoreConverter implements AttributeConverter<HardSoftScore, String> {
@Override
public String convertToDatabaseColumn(HardSoftScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public HardSoftScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return HardSoftScore.parseScore(scoreString);
}
}
|
0 | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin | java-sources/ai/timefold/solver/timefold-solver-jpa/1.26.1/ai/timefold/solver/jpa/api/score/buildin/hardsoftbigdecimal/HardSoftBigDecimalScoreConverter.java | package ai.timefold.solver.jpa.api.score.buildin.hardsoftbigdecimal;
import jakarta.persistence.AttributeConverter;
import jakarta.persistence.Converter;
import ai.timefold.solver.core.api.score.buildin.hardsoftbigdecimal.HardSoftBigDecimalScore;
@Converter
public class HardSoftBigDecimalScoreConverter implements AttributeConverter<HardSoftBigDecimalScore, String> {
@Override
public String convertToDatabaseColumn(HardSoftBigDecimalScore score) {
if (score == null) {
return null;
}
return score.toString();
}
@Override
public HardSoftBigDecimalScore convertToEntityAttribute(String scoreString) {
if (scoreString == null) {
return null;
}
return HardSoftBigDecimalScore.parseScore(scoreString);
}
}
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.