Upgrade recipe 7

SolutionFileIO solutionFileIO = new XStreamSolutionFileIO(CloudBalance.class);

SolutionFileIO<CloudBalance> solutionFileIO = new XStreamSolutionFileIO<>(CloudBalance.class);

public class LectureFilter implements SelectionFilter<Lecture> {

    public boolean accept(ScoreDirector scoreDirector, Lecture lecture) {
        ...
    }

}

public class LectureFilter implements SelectionFilter<CourseSchedule, Lecture> {

    @Override
    public boolean accept(ScoreDirector<CourseSchedule> scoreDirector, Lecture lecture) {
        ...
    }

}

public class DinnerPartySolutionInitializer extends AbstractCustomPhaseCommand {

    public void changeWorkingSolution(ScoreDirector scoreDirector) {
        DinnerParty dinnerParty = (DinnerParty) scoreDirector.getWorkingSolution();
        ...
    }

}

public class DinnerPartySolutionInitializer extends AbstractCustomPhaseCommand<DinnerParty> {

    public void changeWorkingSolution(ScoreDirector<DinnerParty> scoreDirector) {
        DinnerParty dinnerParty = scoreDirector.getWorkingSolution();
        ...
    }

}

      <termination>
        <bestScoreLimit>0/0/-1/-2/-3</bestScoreLimit>
      </termination>

      <termination>
        <bestScoreLimit>[0/0]hard/[-1/-2/-3]soft</bestScoreLimit>
      </termination>

      <score>0/0/-1/-2/-3</score>

      <score>[0/0]hard/[-1/-2/-3]soft</score>

  <termination>
    <calculateCountLimit>100000</calculateCountLimit>
  </termination>

  <termination>
    <scoreCalculationCountLimit>100000</scoreCalculationCountLimit>
  </termination>

      <problemStatisticType>CALCULATE_COUNT_PER_SECOND</problemStatisticType>

      <problemStatisticType>SCORE_CALCULATION_SPEED</problemStatisticType>

Score score = scoreDefinition.fromLevelNumbers(new int[]{0, -200});

Score score = scoreDefinition.fromLevelNumbers(0, new int[]{0, -200});

public final class HardSoftScore extends AbstractScore<HardSoftScore> ... {
    ...
}

public final class HardSoftScore extends AbstractScore<HardSoftScore> ... {
    ...

    public HardSoftScore toInitializedScore() {
        return initScore == 0 ? this : new HardSoftScore(0, hardScore, softScore);
    }

    public HardSoftScore withInitScore(int newInitScore) {
        assertNoInitScore();
        return new HardSoftScore(newInitScore, hardScore, softScore);
    }

}

        @Columns(columns = {
                @Column(name = "hardScore"),
                @Column(name = "softScore")})
        public HardSoftScore getScore() {
            return score;
        }

        @Columns(columns = {
                @Column(name = "initScore"),
                @Column(name = "hardScore"),
                @Column(name = "softScore")})
        public HardSoftScore getScore() {
            return score;
        }

        scoreDirector.beforeProblemFactChanged(computer);
        computer.setMemory(newMemoryCapacity);
        scoreDirector.afterProblemFactChanged(computer);

        scoreDirector.beforeProblemPropertyChanged(computer);
        computer.setMemory(newMemoryCapacity);
        scoreDirector.afterProblemPropertyChanged(computer);

public class StartTimeUpdatingVariableListener implements VariableListener<Task> {

    ...
}

public class StartTimeUpdatingVariableListener implements VariableListener<Task> {

    @Override
    public boolean requiresUniqueEntityEvents() {
        // If you don't need to overwrite this method, you get a small performance gain
        return true;
    }

    ...
}

public final class HardSoftScore extends AbstractScore<HardSoftScore> {
    ...

}

public final class HardSoftScore extends AbstractScore<HardSoftScore> {
    ...

    @Override
    public boolean isCompatibleArithmeticArgument(Score otherScore) {
        return otherScore instanceof HardSoftScore;
    }

}

ScoreDirectorFactory<CloudBalance> scoreDirectorFactory = solver.getScoreDirectorFactory();
ScoreDirector<CloudBalance> guiScoreDirector = scoreDirectorFactory.buildScoreDirector();
...

ScoreDirectorFactory<CloudBalance> scoreDirectorFactory = solver.getScoreDirectorFactory();
ScoreDirector<CloudBalance> guiScoreDirector = scoreDirectorFactory.buildScoreDirector();
...
guiScoreDirector.dispose();

public class NQueens implements PlanningCloneable<NQueens> {
    ...

    public NQueens planningClone() {
        ...
    }

}

public class NQueensSolutionCloner implements SolutionCloner<NQueens> {

    @Override
    public NQueens cloneSolution(CloneLedger ledger, NQueens original) {
        ...
    }

}

@PlanningSolution(solutionCloner = NQueensSolutionCloner.class)
public class NQueens {
    ...
}

public class EditComputerProblemFactChange implements ProblemFactChange<CloudBalance> {

    private final CloudComputer changedComputer;
    ...

    public void doChange(ScoreDirector<CloudBalance> scoreDirector) {
        CloudComputer workingComputer = null;
        for (CloudComputer computer : cloudBalance.getComputerList()) {
            if (changedComputer.getId().equals(computer.getId())) {
                workingComputer = computer;
                break;
            }
        }

        scoreDirector.beforeProblemPropertyChanged(workingComputer);
        workingComputer.setCpuPower(changedComputer.getCpuPower());
        scoreDirector.afterProblemPropertyChanged(workingComputer);
        ...
        scoreDirector.triggerVariableListeners();
    }

}

public class EditComputerProblemFactChange implements ProblemFactChange<CloudBalance> {

    private final CloudComputer changedComputer;
    ...

    public void doChange(ScoreDirector<CloudBalance> scoreDirector) {
        CloudComputer workingComputer = scoreDirector.lookUpWorkingObject(changedComputer);

        scoreDirector.beforeProblemPropertyChanged(workingComputer);
        workingComputer.setCpuPower(changedComputer.getCpuPower());
        scoreDirector.afterProblemPropertyChanged(workingComputer);
        ...
        scoreDirector.triggerVariableListeners();
    }

}

<plannerBenchmark>
  ...
  <warmUpSecondsSpentLimit>30</warmUpSecondsSpentLimit>
  ...
</plannerBenchmark>

<plannerBenchmark>
  ...
</plannerBenchmark>

<plannerBenchmark>
  ...
  <warmUpSecondsSpentLimit>0</warmUpSecondsSpentLimit>
  ...
</plannerBenchmark>

public class MyCustomPhaseCommand extends AbstractCustomPhaseCommand {

    private int mySelectionSize;

    @Override
    public void applyCustomProperties(Map<String, String> customPropertyMap) {
        String mySelectionSizeString = customPropertyMap.get("mySelectionSize");
        try {
            mySelectionSize = mySelectionSizeString == null ? 10 : Integer.parseInt(mySelectionSizeString);
        } catch (NumberFormatException e) {
            throw new IllegalArgumentException("The mySelectionSize (" + mySelectionSizeString + ") cannot be parsed.", e);
        }
        ...
    }

    ...
}

public class MyCustomPhaseCommand extends AbstractCustomPhaseCommand {

    private int mySelectionSize = 10;

    @SuppressWarnings("unused")
    public void setMySelectionSize(int mySelectionSize) {
        this.mySelectionSize = mySelectionSize;
    }

    ...
}

public class CloudBalancingEasyScoreCalculator implements EasyScoreCalculator<CloudBalance> {

    public HardSoftScore calculateScore(CloudBalance cloudBalance, int initScore) {
        ...
        return HardSoftScore.valueOf(initScore, hardScore, softScore);
    }

}

public class CloudBalancingEasyScoreCalculator implements EasyScoreCalculator<CloudBalance> {

    public HardSoftScore calculateScore(CloudBalance cloudBalance) {
        ...
        return HardSoftScore.valueOf(hardScore, softScore);
    }

}

public class CloudBalancingIncrementalScoreCalculator extends AbstractIncrementalScoreCalculator<CloudBalance> {

    public HardSoftScore calculateScore(int initScore) {
        return HardSoftScore.valueOf(initScore, hardScore, softScore);
    }

}

public class CloudBalancingIncrementalScoreCalculator extends AbstractIncrementalScoreCalculator<CloudBalance> {

    public HardSoftScore calculateScore() {
        return HardSoftScore.valueOf(hardScore, softScore);
    }

}

        SimpleScore score = SimpleScore.valueOfInitialized(1234);

        SimpleScore score = SimpleScore.valueOf(1234);

        HardSoftScore score = HardSoftScore.valueOfInitialized(1200, 34);

        HardSoftScore score = HardSoftScore.valueOf(1200, 34);

public class DinnerPartySolutionInitializer extends AbstractCustomPhaseCommand<DinnerParty> {
    ...

    private void initializeSeatDesignationList(ScoreDirector<DinnerParty> scoreDirector, DinnerParty dinnerParty) {
        ...
        for (SeatDesignation seatDesignation : dinnerParty.getSeatDesignationList()) {
            Score bestScore = SimpleScore.valueOfInitialized(Integer.MIN_VALUE);
            ...
            for (Seat seat : undesignatedSeatList) {
                ...
                if (score.toInitializedScore().compareTo(bestScore.toInitializedScore()) > 0) {
                    bestScore = score;
                    ...
                }
            }
            ...
        }
    }

}

public class DinnerPartySolutionInitializer extends AbstractCustomPhaseCommand<DinnerParty> {
    ...

    private void initializeSeatDesignationList(ScoreDirector<DinnerParty> scoreDirector, DinnerParty dinnerParty) {
        ...
        for (SeatDesignation seatDesignation : dinnerParty.getSeatDesignationList()) {
            Score bestScore = SimpleScore.valueOf(Integer.MIN_VALUE);
            ...
            for (Seat seat : undesignatedSeatList) {
                ...
                if (score.compareTo(bestScore) > 0) {
                    bestScore = score;
                    ...
                }
            }
            ...
        }
    }

}

public class CloudComputerChangeMove extends AbstractMove {

    @Override
    public boolean isMoveDoable(ScoreDirector scoreDirector) {
        return !Objects.equals(cloudProcess.getComputer(), toCloudComputer);
    }

    @Override
    public Move createUndoMove(ScoreDirector scoreDirector) {
        return new CloudComputerChangeMove(cloudProcess, cloudProcess.getComputer());
    }

    @Override
    protected void doMoveOnGenuineVariables(ScoreDirector scoreDirector) {
        scoreDirector.beforeVariableChanged(cloudProcess, "computer");
        cloudProcess.setComputer(toCloudComputer);
        scoreDirector.afterVariableChanged(cloudProcess, "computer");
    }

    ...
}

public class CloudComputerChangeMove extends AbstractMove<CloudBalance> {

    @Override
    public boolean isMoveDoable(ScoreDirector<CloudBalance> scoreDirector) {
        return !Objects.equals(cloudProcess.getComputer(), toCloudComputer);
    }

    @Override
    public CloudComputerChangeMove createUndoMove(ScoreDirector<CloudBalance> scoreDirector) {
        return new CloudComputerChangeMove(cloudProcess, cloudProcess.getComputer());
    }

    @Override
    protected void doMoveOnGenuineVariables(ScoreDirector<CloudBalance> scoreDirector) {
        scoreDirector.beforeVariableChanged(cloudProcess, "computer");
        cloudProcess.setComputer(toCloudComputer);
        scoreDirector.afterVariableChanged(cloudProcess, "computer");
    }

    ...
}

public final class HardSoftScore extends AbstractScore<HardSoftScore> ... {
    ...
    @Override
    public String toShortString() {
        return buildShortString((n) -> ((Integer) n).intValue() != 0, HARD_LABEL, SOFT_LABEL);
    }
}

        Move<Solution_> move = ...;
        Move<Solution_> undoMove = move.createUndoMove(scoreDirector);
        move.doMove(scoreDirector);

        Move<Solution_> move = ...;
        Move<Solution_> undoMove = move.doMove(scoreDirector);

public class HardSoftScoreDefinition extends AbstractFeasibilityScoreDefinition<HardSoftScore> {
    ...

    @Override
    public HardSoftScore getZeroScore() {
        return HardSoftScore.ZERO;
    }
}

public class MachineReassignmentIncrementalScoreCalculator
        implements ConstraintMatchAwareIncrementalScoreCalculator<MachineReassignment> {

    ...

    @Override
    public Collection<ConstraintMatchTotal> getConstraintMatchTotals() {
        ...
    }
}

public class MachineReassignmentIncrementalScoreCalculator
        implements ConstraintMatchAwareIncrementalScoreCalculator<MachineReassignment> {

    ...

    @Override
    public Collection<ConstraintMatchTotal> getConstraintMatchTotals() {
        ...
    }

    @Override
    public Map<Object, Indictment> getIndictmentMap() {
        return null; // Calculate it non-incrementally from getConstraintMatchTotals()
    }
}

public class CloudComputerChangeMoveFactory implements MoveListFactory<CloudBalance> {

    @Override
    public List<Move> createMoveList(CloudBalance solution) {
        ...
    }

}

public class CloudComputerChangeMoveFactory implements MoveListFactory<CloudBalance> {

    @Override
    public List<ChangeMove<CloudBalance>> createMoveList(CloudBalance nQueens) {
        ...
    }

}

public class RowChangeMoveFactory implements MoveListFactory<CloudBalance> {

    @Override
    public List<CloudComputerChangeMove> createMoveList(CloudBalance nQueens) {
        ...
    }

}

public class CheapTimePillarSlideMoveIteratorFactory implements MoveIteratorFactory<CheapTimeSolution> {

    public Iterator<Move> createOriginalMoveIterator(...) {...}
    public Iterator<Move> createRandomMoveIterator(...) {...}

}

public class CheapTimePillarSlideMoveIteratorFactory implements MoveIteratorFactory<CheapTimeSolution> {

    public Iterator<CheapTimePillarSlideMove> createOriginalMoveIterator(...) {...}
    public Iterator<CheapTimePillarSlideMove> createRandomMoveIterator(...) {...}

}

  <valueSelector>
    <variableName>room</variableName>
  </valueSelector>

  <valueSelector variableName="room"/>

  <constructionHeuristic>
    <queuedEntityPlacer>
      <entitySelector id="placerEntitySelector"/>
      <changeMoveSelector>
        <entitySelector mimicSelectorRef="placerEntitySelector"/>
        <valueSelector variableName="period"/>
      </changeMoveSelector>
      <changeMoveSelector>
        <entitySelector mimicSelectorRef="placerEntitySelector"/>
        <valueSelector variableName="room"/>
      </changeMoveSelector>
    </queuedEntityPlacer>
  </constructionHeuristic>

  <constructionHeuristic>
    <constructionHeuristicType>FIRST_FIT</constructionHeuristicType>
    <changeMoveSelector>
      <valueSelector variableName="period"/>
    </changeMoveSelector>
    <changeMoveSelector>
      <valueSelector variableName="room"/>
    </changeMoveSelector>
  </constructionHeuristic>

public class VehicleRoutingFileIO implements SolutionFileIO<VehicleRoutingSolution> {

    @Override
    public String getInputFileExtension() {
        return "vrp";
    }

    @Override
    public String getOutputFileExtension() {
        return "vrp";
    }

    ...
}

public class VehicleRoutingFileIO implements SolutionFileIO<VehicleRoutingSolution> {

    @Override
    public String getInputFileExtension() {
        return "vrp";
    }

    ...
}

    CloudBalance problem1 = readFromDatabase(...);
    CloudBalance problem2 = readFromDatabase(...);
    ...
    CloudBalanceFileIO solutionFileIO = new CloudBalanceFileIO();
    solutionFileIO.write(problem1, new File("tmp/problem1.xml"));
    solutionFileIO.write(problem2, new File("tmp/problem1.xml"));
    ...
    PlannerBenchmark plannerBenchmark = benchmarkFactory.buildPlannerBenchmark();
    plannerBenchmark.benchmark();

    <problemBenchmarks>
      <solutionFileIOClass>...CloudBalanceFileIO</solutionFileIOClass>
      <inputSolutionFile>tmp/problem1.xml</inputSolutionFile>
      <inputSolutionFile>tmp/problem2.xml</inputSolutionFile>
      ...
    </problemBenchmarks>

    CloudBalance problem1 = readFromDatabase(...);
    CloudBalance problem2 = readFromDatabase(...);
    ...
    PlannerBenchmark plannerBenchmark = benchmarkFactory.buildPlannerBenchmark(problem1, problem2, ...);
    plannerBenchmark.benchmark();

    <problemBenchmarks>
    </problemBenchmarks>

    <problemBenchmarks>
      ...
      <problemStatisticType>BEST_SCORE</problemStatisticType>
    </problemBenchmarks>

    <problemBenchmarks>
      ...
    </problemBenchmarks>

    <problemBenchmarks>
      ...
      <problemStatisticEnabled>false</problemStatisticEnabled>
    </problemBenchmarks>

@PlanningEntity(movableEntitySelectionFilter = ParentFilter.class)
public class Animal {
   ...
}

@PlanningEntity(movableEntitySelectionFilter = ParentFilter.class)
public class Dog extends Animal {
   ...
}

@PlanningEntity(movableEntitySelectionFilter = ParentFilter.class)
public class Animal {
   ...
}

@PlanningEntity()
public class Dog extends Animal {
   ...
}

Collections.sort(indictmentList);

Collections.sort(indictmentList, new IndictmentScoreTotalComparator());

plannerBenchmark.benchmark();
// Afterwards manually find the benchmark dir to open the report

plannerBenchmark.benchmarkAndShowReportInBrowser();

    ObjectMapper objectMapper = new ObjectMapper();

@PlanningSolution
public class MySolution {

    @JsonSerialize(using = ScoreJacksonJsonSerializer.class)
    @JsonDeserialize(using = HardSoftScoreJacksonJsonDeserializer.class)
    private HardSoftScore score;

    ...
}

    ObjectMapper objectMapper = new ObjectMapper();
    objectMapper.registerModule(OptaPlannerJacksonModule.createModule());

@PlanningSolution
public class MySolution {

    private HardSoftScore score;

    ...
}

@JsonSerialize(using = ScoreJacksonJsonSerializer.class)
@JsonDeserialize(using = HardSoftScoreJacksonJsonDeserializer.class)
private HardSoftScore score;

@JsonSerialize(using = HardSoftScoreJacksonJsonSerializer.class)
@JsonDeserialize(using = HardSoftScoreJacksonJsonDeserializer.class)
private HardSoftScore score;

  <solver>
    ...
    <partitionedSearch>
      <threadFactoryClass>...MyAppServerThreadFactory</threadFactoryClass>
      ...
    </partitionedSearch>
  </solver>

  <solver>
    <threadFactoryClass>...MyAppServerThreadFactory</threadFactoryClass>
    ...
    <partitionedSearch>
      ...
    </partitionedSearch>
  </solver>

Score score = constraintMatchTotal.getScoreTotal();

Score score = constraintMatchTotal.getScore();

Score score = indictment.getScoreTotal();

Score score = indictment.getScore();

indictmentList.sort(new IndictmentScoreTotalComparator());

indictmentList.sort(new IndictmentScoreComparator());

private SolverFactory<MySolution> base;

public void userRequest(..., long userInput) {
    SolverFactory<MySolution> solverFactory = base.cloneSolverFactory();
    solverFactory.getSolverConfig()
            .getTerminationConfig()
            .setMinutesSpentLimit(userInput);
    Solver<MySolution> solver = solverFactory.buildSolver();
    ...
}

private SolverConfig base;

public void userRequest(..., long userInput) {
    SolverConfig solverConfig = new SolverConfig(base); // Copy it
    solverConfig.getTerminationConfig()
            .setMinutesSpentLimit(userInput);
    SolverFactory<MySolution> solverFactory = SolverFactory.create(solverConfig);
    Solver<MySolution> solver = solverFactory.buildSolver();
    ...
}

SolverFactory<MySolution> solverFactory = SolverFactory.createEmpty();
SolverConfig solverConfig = solverFactory.getSolverConfig()
...
Solver<MySolution> solver = solverFactory.buildSolver();

SolverConfig solverConfig = new SolverConfig();
...
SolverFactory<MySolution> solverFactory = SolverFactory.create(solverConfig);
Solver<MySolution> solver = solverFactory.buildSolver();

PlannerBenchmarkFactory benchmarkFactory = PlannerBenchmarkFactory.createFromXmlResource(
        ".../cloudBalancingBenchmarkConfig.xml");
PlannerBenchmarkConfig benchmarkConfig = benchmarkFactory.getPlannerBenchmarkConfig();
...
PlannerBenchmark benchmark = benchmarkFactory.buildPlannerBenchmark();

PlannerBenchmarkConfig benchmarkConfig = PlannerBenchmarkConfig.createFromXmlResource(
        ".../cloudBalancingBenchmarkConfig.xml");
...
PlannerBenchmarkFactory benchmarkFactory = PlannerBenchmarkFactory.create(benchmarkConfig);
PlannerBenchmark benchmark = benchmarkFactory.buildPlannerBenchmark();

PlannerBenchmarkFactory benchmarkFactory = PlannerBenchmarkFactory.createFromXmlResource(
        ".../cloudBalancingBenchmarkConfig.xml");
BenchmarkAggregatorFrame.createAndDisplay(benchmarkFactory);

BenchmarkAggregatorFrame.createAndDisplayFromXmlResource(
        ".../cloudBalancingBenchmarkConfig.xml");

solver = ...;
solution = solver.getBestSolution();
score = solver.getBestScore();
timeMillisSpent = solver.getTimeMillisSpent();

solver = ...;
solver.addEventListener(event -> {
    solution = event.getNewBestSolution();
    score = event.getNewBestScore();
    timeMillisSpent = event.getTimeMillisSpent();
});

solver = ...;
scoreExplanation = solver.explainBestScore();

MySolution solution = ...;
ScoreManager<MySolution> scoreManager = ...;
scoreExplanation = scoreManager.explainScore(solution);

@PlanningSolution
public class MyPlanningSolution {

    private SimpleDoubleScore score;

    ...

}

@PlanningSolution
public class MyPlanningSolution {

    private SimpleLongScore score;

    ...

}

score = score.toInitializedScore();

score = score.withInitScore(0);

NaturalScoreComparator comparator = new NaturalScoreComparator();
ConstraintMatchScoreComparator comparator2 = new ConstraintMatchScoreComparator();

Comparator<Score> comparator = Comparable::compareTo;
Comparator<ConstraintMatch> comparator2 = Comparator.comparing(ConstraintMatch::getScore);

@PlanningEntity(movableEntitySelectionFilter = MyMovableEntitySelectionFilter.class)

@PlanningEntity(pinningFilter = MyPinningFilter.class)

    <dependency>
      <groupId>org.quarkus</groupId>
      <artifactId>quarkus-optaplanner</artifactId>
    </dependency>
    <dependency>
      <groupId>org.quarkus</groupId>
      <artifactId>quarkus-optaplanner-jackson</artifactId>
    </dependency>

    <dependency>
      <groupId>org.optaplanner</groupId>
      <artifactId>optaplanner-quarkus</artifactId>
    </dependency>
    <dependency>
      <groupId>org.optaplanner</groupId>
      <artifactId>optaplanner-quarkus-jackson</artifactId>
    </dependency>

    <dependency>
      <groupId>org.quarkus</groupId>
      <artifactId>quarkus-optaplanner</artifactId>
    </dependency>
    <dependency>
      <groupId>org.quarkus</groupId>
      <artifactId>quarkus-optaplanner-jsonb</artifactId>
    </dependency>

    <dependency>
      <groupId>org.optaplanner</groupId>
      <artifactId>optaplanner-quarkus</artifactId>
    </dependency>
    <dependency>
      <groupId>org.optaplanner</groupId>
      <artifactId>optaplanner-quarkus-jsonb</artifactId>
    </dependency>

    <solver>
        ...
        <moveThreadCount>availableProcessorCount - 1</moveThreadCount>
        ...
    </solver>

    <solver>
        ...
        <moveThreadCount>1</moveThreadCount> <!-- Alternatively, use "AUTO" or omit entirely. -->
        ...
    </solver>

    <plannerBenchmark>
      ...
      <parallelBenchmarkCount>availableProcessorCount - 1</parallelBenchmarkCount>
      ...
    </plannerBenchmark>

    <plannerBenchmark>
      ...
      <parallelBenchmarkCount>1</parallelBenchmarkCount> <!-- Alternatively, use "AUTO" or omit entirely. -->
      ...
    </plannerBenchmark>