import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void convertAll() {
    File inputDir = getInputDir();
    if (!inputDir.exists()) {
        throw new IllegalStateException("The directory inputDir (" + inputDir.getAbsolutePath()
                + ") does not exist.");
    }
    File outputDir = getOutputDir();
    outputDir.mkdirs();
    File[] inputFiles = inputDir.listFiles();
    Arrays.sort(inputFiles, new ProblemFileComparator());
    for (File inputFile : inputFiles) {
        String inputFileName = inputFile.getName();
        if (inputFileName.endsWith("." + getInputFileSuffix())) {
            Solution solution = solutionDao.readSolution(inputFile);
            String outputFileName = inputFileName.substring(0,
                    inputFileName.length() - getInputFileSuffix().length())
                    + getOutputFileSuffix();
            File outputFile = new File(outputDir, outputFileName);
            writeSolution(solution, outputFile);
        }
    }
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public List<ShiftAssignment> plan() {
    SolverFactory<Solution> solverFactory = SolverFactory.createFromXmlResource("planner/EmployeeRosteringSolverConfig.xml");
    Solver solver = solverFactory.buildSolver();

    EmployeeRoster employeeRoster = new EmployeeRoster();
    employeeRoster.setCode("TEST");
    employeeRoster.setSkillList(employeeRepository.listSkills());
    employeeRoster.setShiftTypeList(shiftRepository.listShiftTypes());
    employeeRoster.setShiftTypeSkillRequirementList(generateShiftTypeSkillRequirements());
    employeeRoster.setPatternList(patternsRepository.listAll());
    employeeRoster.setContractList(contractRepository.listAll());
    employeeRoster.setContractLineList(generateContractLines());
    employeeRoster.setPatternContractLineList(generateContractPatternList());
    employeeRoster.setEmployeeList(employeeRepository.listAll());
    employeeRoster.setSkillProficiencyList(generateSkillProficiency());
    employeeRoster.setShiftDateList(shiftRepository.listShiftDates());
    employeeRoster.setShiftList(shiftRepository.listShifts());
    employeeRoster.setDayOffRequestList(employeeRepository.listDayOffRequests());
    employeeRoster.setDayOnRequestList(employeeRepository.listDayOnRequests());
    employeeRoster.setShiftOffRequestList(employeeRepository.listShiftOffRequests());
    employeeRoster.setShiftOnRequestList(employeeRepository.listShiftOnRequests());
    employeeRoster.setEmployeeRosterParametrization(generateEmployeeRosterInfo());
    employeeRoster.setShiftAssignmentList(generateAssigments());

    employeeRoster = (EmployeeRoster) solver.solve(employeeRoster);
    final HardSoftScore score = employeeRoster.getScore();
    for (ShiftAssignment shiftAssignment : employeeRoster.getShiftAssignmentList()) {
        shiftRepository.createShiftAssignment(shiftAssignment.getShift(), shiftAssignment.getEmployee());
    }
    messageService.informUser(String.format("'%s' score ", score.toString()));

    return shiftRepository.listShiftAssignments();
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void resetPanel(Solution solution) {
    CloudBalance cloudBalance = (CloudBalance) solution;
    maximumComputerCpuPower = 0;
    maximumComputerMemory = 0;
    maximumComputerNetworkBandwidth = 0;
    for (CloudComputer computer : cloudBalance.getComputerList()) {
        if (computer.getCpuPower() > maximumComputerCpuPower) {
            maximumComputerCpuPower = computer.getCpuPower();
        }
        if (computer.getMemory() > maximumComputerMemory) {
            maximumComputerMemory = computer.getMemory();
        }
        if (computer.getNetworkBandwidth() > maximumComputerNetworkBandwidth) {
            maximumComputerNetworkBandwidth = computer.getNetworkBandwidth();
        }
    }
    for (CloudComputerPanel computerPanel : computerToPanelMap.values()) {
        if (computerPanel.getComputer() != null) {
            computersPanel.remove(computerPanel);
        }
    }
    computerToPanelMap.clear();
    computersPanel.removeAll();
    unassignedPanel = new CloudComputerPanel(this, null);
    computersPanel.add(unassignedPanel);
    computerToPanelMap.put(null, unassignedPanel);
    updatePanel(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void doProblemFactChange(ProblemFactChange problemFactChange, boolean reset) {
    solutionBusiness.doProblemFactChange(problemFactChange);
    Solution solution = solutionBusiness.getSolution();
    if (reset) {
        resetPanel(solution);
    } else {
        updatePanel(solution);
    }
    validate();
    solverAndPersistenceFrame.refreshScoreField(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void bestSolutionChanged() {
    Solution solution = solutionBusiness.getSolution();
    if (refreshScreenDuringSolvingCheckBox.isSelected()) {
        solutionPanel.updatePanel(solution);
        validate(); // TODO remove me?
    }
    refreshScoreField(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void refreshScoreField(Solution solution) {
    // TODO Fix after https://issues.jboss.org/browse/PLANNER-405
    int uninitializedVariableCount = solutionBusiness.getUninitializedVariableCount();
    Score score = solution.getScore();
    scoreField.setForeground(determineScoreFieldForeground(uninitializedVariableCount, score));
    scoreField.setText("Latest best score: " + ScoreUtils.getScoreWithUninitializedPrefix(uninitializedVariableCount, score));
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void writeSolution(Solution solution, File outputFile) {
    BufferedWriter bufferedWriter = null;
    try {
        bufferedWriter = new BufferedWriter(new OutputStreamWriter(new FileOutputStream(outputFile), "UTF-8"));
        TxtOutputBuilder txtOutputBuilder = createTxtOutputBuilder();
        txtOutputBuilder.setBufferedWriter(bufferedWriter);
        txtOutputBuilder.setSolution(solution);
        txtOutputBuilder.writeSolution();
    } catch (IOException e) {
        throw new IllegalArgumentException("Could not write the file (" + outputFile.getName() + ").", e);
    } finally {
        IOUtils.closeQuietly(bufferedWriter);
    }
    logger.info("Exported: {}", outputFile);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public Solution readSolution() throws IOException {
    String firstLine = readStringValue();
    if (firstLine.matches("\\s*NAME\\s*:.*")) {
        solution = new VehicleRoutingSolution();
        solution.setId(0L);
        solution.setName(removePrefixSuffixFromLine(firstLine, "\\s*NAME\\s*:", ""));
        readVrpWebFormat();
    } else if (splitBySpacesOrTabs(firstLine).length == 3) {
        solution = new VehicleRoutingSolution();
        solution.setId(0L);
        /* ORIGINAL
        solution.setName(FilenameUtils.getBaseName(inputFile.getName())); */
        solution.setName(FilenameUtils.getBaseName(inputFileNameWithExt));
        String[] tokens = splitBySpacesOrTabs(firstLine, 3);
        customerListSize = Integer.parseInt(tokens[0]);
        vehicleListSize = Integer.parseInt(tokens[1]);
        capacity = Integer.parseInt(tokens[2]);
        readCourseraFormat();
    } else {
        solution = new TimeWindowedVehicleRoutingSolution();
        solution.setId(0L);
        solution.setName(firstLine);
        readTimeWindowedFormat();
    }
     /* TODO enable logger
    BigInteger possibleSolutionSize
            = factorial(customerListSize + vehicleListSize - 1).divide(factorial(vehicleListSize - 1));

    logger.info("VehicleRoutingSolution {} has {} depots, {} vehicles and {} customers with a search space of {}.",
            getInputId(),
            solution.getDepotList().size(),
            solution.getVehicleList().size(),
            solution.getCustomerList().size(),
            getFlooredPossibleSolutionSize(possibleSolutionSize));
    */
    return solution;
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void updatePanel(Solution solution) {
    resetPanel(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void resetScreen() {
    Solution solution = solutionBusiness.getSolution();
    solutionPanel.resetPanel(solution);
    validate();
    refreshScoreField(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
protected void convert(File inputFile, File outputFile) {
    Solution solution = readSolution(inputFile);
    solutionDao.writeSolution(solution, outputFile);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public Solution readSolution(File inputSolutionFile) {
    Solution solution = xStreamSolutionFileIO.read(inputSolutionFile);
    logger.info("Opened: {}", inputSolutionFile);
    return solution;
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void writeSolution(Solution solution, File outputSolutionFile) {
    xStreamSolutionFileIO.write(solution, outputSolutionFile);
    logger.info("Saved: {}", outputSolutionFile);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void setSolution(Solution solution) {
    guiScoreDirector.setWorkingSolution(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void importSolution(File file) {
    AbstractSolutionImporter importer = determineImporter(file);
    Solution solution = importer.readSolution(file);
    solutionFileName = file.getName();
    guiScoreDirector.setWorkingSolution(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void openSolution(File file) {
    Solution solution = solutionDao.readSolution(file);
    solutionFileName = file.getName();
    guiScoreDirector.setWorkingSolution(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void saveSolution(File file) {
    Solution solution = guiScoreDirector.getWorkingSolution();
    solutionDao.writeSolution(solution, file);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void exportSolution(File file) {
    Solution solution = guiScoreDirector.getWorkingSolution();
    exporter.writeSolution(solution, file);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
public void resetPanel(Solution solutionObject) {
    ReindeerRoutingSolution solution = (ReindeerRoutingSolution) solutionObject;
    reindeerRoutingWorldPanel.resetPanel(solution);
}
 

import org.optaplanner.core.api.domain.solution.Solution; //导入依赖的package包/类
@Override
public void updatePanel(Solution solutionObject) {
    ReindeerRoutingSolution solution = (ReindeerRoutingSolution) solutionObject;
    reindeerRoutingWorldPanel.updatePanel(solution);
}