Example usage for java.util.concurrent CompletableFuture anyOf

Introduction

In this page you can find the example usage for java.util.concurrent CompletableFuture anyOf.

Prototype

public static CompletableFuture<Object> anyOf(CompletableFuture<?>... cfs) 

Source Link

Document

Returns a new CompletableFuture that is completed when any of the given CompletableFutures complete, with the same result.

Usage

From source file:eu.itesla_project.modules.wca.WCATool.java

@Override
public void run(CommandLine line) throws Exception {
    Path caseFile = Paths.get(line.getOptionValue("case-file"));
    String offlineWorkflowId = line.getOptionValue("offline-workflow-id"); // can be null meaning use no offline security rules
    Interval histoInterval = Interval.parse(line.getOptionValue("history-interval"));
    String rulesDbName = line.hasOption("rules-db-name") ? line.getOptionValue("rules-db-name")
            : OfflineConfig.DEFAULT_RULES_DB_NAME;
    double purityThreshold = DEFAULT_PURITY_THRESHOLD;
    if (line.hasOption("purity-threshold")) {
        purityThreshold = Double.parseDouble(line.getOptionValue("purity-threshold"));
    }//from   w w w  . jav a 2s.c  o m
    Set<SecurityIndexType> securityIndexTypes = null;
    if (line.hasOption("security-index-types")) {
        securityIndexTypes = Arrays.stream(line.getOptionValue("security-index-types").split(","))
                .map(SecurityIndexType::valueOf).collect(Collectors.toSet());
    }
    Path outputCsvFile = null;
    if (line.hasOption("output-csv-file")) {
        outputCsvFile = Paths.get(line.getOptionValue("output-csv-file"));
    }
    boolean stopWcaOnViolations = DEFAULT_STOP_WCA_ON_VIOLATIONS;
    if (line.hasOption("stop-on-violations")) {
        stopWcaOnViolations = Boolean.parseBoolean(line.getOptionValue("stop-on-violations"));
    }

    try (ComputationManager computationManager = new LocalComputationManager()) {
        WCAParameters parameters = new WCAParameters(histoInterval, offlineWorkflowId, securityIndexTypes,
                purityThreshold, stopWcaOnViolations);
        OnlineConfig config = OnlineConfig.load();
        ContingenciesAndActionsDatabaseClient contingenciesDb = config.getContingencyDbClientFactoryClass()
                .newInstance().create();
        LoadFlowFactory loadFlowFactory = config.getLoadFlowFactoryClass().newInstance();
        WCAFactory wcaFactory = config.getWcaFactoryClass().newInstance();
        try (HistoDbClient histoDbClient = new SynchronizedHistoDbClient(
                config.getHistoDbClientFactoryClass().newInstance().create());
                RulesDbClient rulesDbClient = config.getRulesDbClientFactoryClass().newInstance()
                        .create(rulesDbName)) {

            UncertaintiesAnalyserFactory uncertaintiesAnalyserFactory = config
                    .getUncertaintiesAnalyserFactoryClass().newInstance();

            if (Files.isRegularFile(caseFile)) {
                if (outputCsvFile != null) {
                    throw new RuntimeException(
                            "In case of single wca, only standard output pretty print is supported");
                }
                System.out.println("loading case...");
                // load the network
                Network network = Importers.loadNetwork(caseFile);
                if (network == null) {
                    throw new RuntimeException("Case '" + caseFile + "' not found");
                }
                network.getStateManager().allowStateMultiThreadAccess(true);

                WCA wca = wcaFactory.create(network, computationManager, histoDbClient, rulesDbClient,
                        uncertaintiesAnalyserFactory, contingenciesDb, loadFlowFactory);
                WCAAsyncResult result = wca.runAsync(StateManager.INITIAL_STATE_ID, parameters).join();

                Table table = new Table(3, BorderStyle.CLASSIC_WIDE);
                table.addCell("Contingency");
                table.addCell("Cluster");
                table.addCell("Causes");

                List<CompletableFuture<WCACluster>> futureClusters = new LinkedList<>(result.getClusters());
                while (futureClusters.size() > 0) {
                    CompletableFuture
                            .anyOf(futureClusters.toArray(new CompletableFuture[futureClusters.size()])).join();
                    for (Iterator<CompletableFuture<WCACluster>> it = futureClusters.iterator(); it
                            .hasNext();) {
                        CompletableFuture<WCACluster> futureCluster = it.next();
                        if (futureCluster.isDone()) {
                            it.remove();
                            WCACluster cluster = futureCluster.get();

                            if (cluster != null) {
                                System.out.println("contingency " + cluster.getContingency().getId() + " done: "
                                        + cluster.getNum() + " (" + cluster.getOrigin() + ")");

                                table.addCell(cluster.getContingency().getId());
                                table.addCell(cluster.getNum() + " (" + cluster.getOrigin() + ")");
                                List<String> sortedCauses = cluster.getCauses().stream().sorted()
                                        .collect(Collectors.toList());
                                if (sortedCauses != null && sortedCauses.size() > 0) {
                                    table.addCell(sortedCauses.get(0));
                                    for (int i = 1; i < sortedCauses.size(); i++) {
                                        table.addCell("");
                                        table.addCell("");
                                        table.addCell(sortedCauses.get(i));
                                    }
                                } else {
                                    table.addCell("");
                                }
                            }
                        }
                    }
                }

                System.out.println(table.render());
            } else if (Files.isDirectory(caseFile)) {
                if (outputCsvFile == null) {
                    throw new RuntimeException(
                            "In case of multiple wca, you have to specify and ouput to csv file");
                }

                Map<String, Map<String, WCACluster>> clusterPerContingencyPerBaseCase = Collections
                        .synchronizedMap(new TreeMap<>());
                Set<String> contingencyIds = Collections.synchronizedSet(new TreeSet<>());

                Importers.loadNetworks(caseFile, true, network -> {
                    try {
                        network.getStateManager().allowStateMultiThreadAccess(true);
                        String baseStateId = network.getId();
                        network.getStateManager().cloneState(StateManager.INITIAL_STATE_ID, baseStateId);
                        network.getStateManager().setWorkingState(baseStateId);

                        WCA wca = wcaFactory.create(network, computationManager, histoDbClient, rulesDbClient,
                                uncertaintiesAnalyserFactory, contingenciesDb, loadFlowFactory);
                        WCAAsyncResult result = wca.runAsync(baseStateId, parameters).join();

                        Map<String, WCACluster> clusterPerContingency = new HashMap<>();

                        List<CompletableFuture<WCACluster>> futureClusters = new LinkedList<>(
                                result.getClusters());
                        while (futureClusters.size() > 0) {
                            CompletableFuture
                                    .anyOf(futureClusters.toArray(new CompletableFuture[futureClusters.size()]))
                                    .join();
                            for (Iterator<CompletableFuture<WCACluster>> it = futureClusters.iterator(); it
                                    .hasNext();) {
                                CompletableFuture<WCACluster> futureCluster = it.next();
                                if (futureCluster.isDone()) {
                                    it.remove();
                                    WCACluster cluster = futureCluster.get();
                                    if (cluster != null) {
                                        System.out.println("case " + network.getId() + ", contingency "
                                                + cluster.getContingency().getId() + " done: "
                                                + cluster.getNum() + " (" + cluster.getOrigin() + ")");

                                        clusterPerContingency.put(cluster.getContingency().getId(), cluster);
                                        contingencyIds.add(cluster.getContingency().getId());
                                    }
                                }
                            }
                        }

                        clusterPerContingencyPerBaseCase.put(network.getId(), clusterPerContingency);
                    } catch (Exception e) {
                        LOGGER.error(e.toString(), e);
                    }
                }, dataSource -> System.out.println("loading case " + dataSource.getBaseName() + "..."));

                writeClustersCsv(clusterPerContingencyPerBaseCase, contingencyIds, outputCsvFile);
            }
        }
    }
}

---