DirectedGraphTranslator.java

            dataByTaskMinMax[0][2] = task22;
            dataByTaskMinMax[0][3] = numMin.get(1);
            dataByTaskMinMax[0][4] = min;

            dataByTaskMinMax[1][0] = task12;
            dataByTaskMinMax[1][1] = numMax.get(0);
            dataByTaskMinMax[1][2] = task22;
            dataByTaskMinMax[1][3] = numMax.get(1);
            dataByTaskMinMax[1][4] = max;

        }

        return dataByTaskMinMax;
    }

    // fill the Min max delay table on main latency analysis frame for tainted data
    public Object[][] latencyMinMaxAnalysisTaintedData(String task12ID, String task22ID, Vector<SimulationTransaction> transFile1) {
        List<Integer> times1MinMAx = new ArrayList<Integer>();
        List<Integer> times2MinMAx = new ArrayList<Integer>();

        String[] task1 = task12ID.split("__");

        int task1index = task1.length;

        idTask1 = task1[task1index - 1];

        String[] task2 = task22ID.split("__");

        int task2index = task2.length;

        idTask2 = task2[task2index - 1];

        String task12 = nameIDTaskList.get(idTask1);
        String task22 = nameIDTaskList.get(idTask2);

        times1MinMAx = times1;
        times2MinMAx = times2;

        HashMap<Integer, ArrayList<Integer>> minTimes = new HashMap<Integer, ArrayList<Integer>>();

        int index = 0;
        for (int time1 : times1MinMAx) {
            int match = Integer.MAX_VALUE;
            // Find the first subsequent transaction
            int time = Integer.MAX_VALUE;

            if (times2MinMAx.get(index) > 0) {

                int time2 = times2MinMAx.get(index);
                int diff = time2 - time1;
                if (diff < time && diff >= 0) {
                    time = diff;
                    match = time2;
                }

            }

            if (time != Integer.MAX_VALUE) {
                ArrayList<Integer> startEndT = new ArrayList<Integer>();
                startEndT.add(time1);
                startEndT.add(match);
                minTimes.put(time, startEndT);
            }

            index++;
        }
        dataByTaskMinMax = new Object[2][5];

        if (minTimes.size() > 0) {
            Integer min = Collections.min(minTimes.keySet());
            Integer max = Collections.max(minTimes.keySet());

            dataByTaskMinMax = new Object[2][5];

            ArrayList<Integer> numMax = minTimes.get(max);
            ArrayList<Integer> numMin = minTimes.get(min);

            dataByTaskMinMax[0][0] = task12;
            dataByTaskMinMax[0][1] = numMin.get(0);
            dataByTaskMinMax[0][2] = task22;
            dataByTaskMinMax[0][3] = numMin.get(1);
            dataByTaskMinMax[0][4] = min;

            dataByTaskMinMax[1][0] = task12;
            dataByTaskMinMax[1][1] = numMax.get(0);
            dataByTaskMinMax[1][2] = task22;
            dataByTaskMinMax[1][3] = numMax.get(1);
            dataByTaskMinMax[1][4] = max;

        }

        return dataByTaskMinMax;
    }

    // fill the detailed latency table once a row is selected from min/max table
    public Object[][] getTasksByRowMinMax(int row) {
        Object[][] dataByTaskRowDetails = new Object[relatedsimTraces.size()][5];

        int i = 0;

        for (SimulationTransaction st : relatedsimTraces) {

            dataByTaskRowDetails[i][0] = st.command;
            dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
            dataByTaskRowDetails[i][2] = st.deviceName;
            dataByTaskRowDetails[i][3] = Integer.valueOf(st.startTime);
            dataByTaskRowDetails[i][4] = Integer.valueOf(st.endTime);
            i++;
        }

        return dataByTaskRowDetails;
    }

    // fill the tasks that run on the same hardware but don't belong to the path
    // between selected activities
    public Object[][] getTaskHWByRowDetailsMinMax(int row) {
        Object[][] dataByTaskRowDetails = new Object[delayDueTosimTraces.size()][5];

        int i = 0;

        for (SimulationTransaction st : delayDueTosimTraces) {

            dataByTaskRowDetails[i][0] = st.command;
            dataByTaskRowDetails[i][1] = nameIDTaskList.get(st.id);
            dataByTaskRowDetails[i][2] = st.deviceName;
            dataByTaskRowDetails[i][3] = Integer.valueOf(st.startTime);
            dataByTaskRowDetails[i][4] = Integer.valueOf(st.endTime);

            i++;
        }

        return dataByTaskRowDetails;
    }

    // import graph in .graphml format
    public void importGraph(String filename) throws ExportException, IOException, ImportException {

        FileReader ps = new FileReader(filename + ".graphml");
        // gmlExporter.exportGraph(g, PS);

        // FileWriter PS2 = new FileWriter(filename + "test.graphml");

        VertexProvider<String> vertexProvider = (id, attributes) -> {
            String cv = new String(id);
            return cv;
        };

        EdgeProvider<String, DefaultEdge> edgeProvider = (from, to, label, attributes) -> new DefaultEdge();

        GraphMLImporter<String, DefaultEdge> importer = new GraphMLImporter<String, DefaultEdge>(vertexProvider, edgeProvider);

        Graph<String, DefaultEdge> importedGraph = null;

        importer.importGraph(importedGraph, ps);

    }

    public List<TMLComponentDesignPanel> getCpanels() {
        return cpanels;
    }

    public void setCpanels(List<TMLComponentDesignPanel> cpanels) {
        this.cpanels = cpanels;
    }

    public HashMap<String, String> getNameIDTaskList() {
        return nameIDTaskList;
    }

    public JScrollPane getScrollPane() {
        return scrollPane;
    }

    public static void setScrollPane(JScrollPane scrollPane) {
        DirectedGraphTranslator.scrollPane = scrollPane;
    }

    public String checkPath(String task12ID, String task22ID) {

        Boolean isPath = false;

        String result = "";

        String[] task1 = task12ID.split("__");

        int task1index = task1.length;

        idTask1 = task1[task1index - 1];

        String[] task2 = task22ID.split("__");

        int task2index = task2.length;

        idTask2 = task2[task2index - 1];

        String task12 = nameIDTaskList.get(idTask1);
        String task22 = nameIDTaskList.get(idTask2);

        vertex v1 = getvertex(task12);
        vertex v2 = getvertex(task22);

        GraphPath<vertex, DefaultEdge> pathToOrigin = DijkstraShortestPath.findPathBetween(g, v1, v2);

        if (pathToOrigin != null && pathToOrigin.getLength() > 0) {

            isPath = true;

        }

        if (isPath) {

            result = "A path exists between operators";
        } else {
            result = "No path between operators";
        }

        return result;
    }

    public Vector<String> getreadChannelNodes() {

        return readChannelTransactions;
    }

    public Vector<String> getwriteChannelNodes() {

        return writeChannelTransactions;
    }

    public String addRule(String node1, String node2, Vector<String> writeChannelTransactions, String ruleDirection) {

        vertex v1 = getvertex(node1);
        vertex v2 = getvertex(node2);

        vertex v1Channel = null, v2Channel = null;

        String message = "";

        if (v2Channel == null && Graphs.vertexHasSuccessors(g, v2)) {
            for (vertex n : Graphs.successorListOf(g, v2)) {
                if (n.getType() == vertex.TYPE_CHANNEL) {
                    v2Channel = n;
                    break;

                }
            }
        }

        Boolean hasWriteVertex = false;
        if (Graphs.vertexHasPredecessors(g, v1)) {
            for (vertex n : Graphs.predecessorListOf(g, v1)) {

                if (n.getType() == vertex.TYPE_CHANNEL) {

                    if (Graphs.vertexHasPredecessors(g, n)) {
                        for (vertex writenode : Graphs.predecessorListOf(g, n)) {

                            if (writeChannelTransactions.contains(writenode.getId())) {
                                hasWriteVertex = true;
                                break;
                            }

                        }

                    }

                    if (hasWriteVertex) {
                        v1Channel = n;
                        break;
                    } else {
                        v1Channel = v1;

                    }

                }
            }
        }

        if (v1Channel != null && v2Channel != null) {

            if (ruleDirection.equals("After")) {

                if (ruleAddedEdges.containsKey(v2Channel)) {
                    ruleAddedEdges.get(v2Channel).add(v1Channel);

                    message = "Rule between " + v1Channel + " and " + v2Channel + " was added";

                } else {
                    List<vertex> sendVertex = new ArrayList<vertex>();
                    sendVertex.add(v1Channel);

                    ruleAddedEdges.put(v2Channel, sendVertex);

                    message = "Rule between " + v1Channel + " and " + v2Channel + " was added";

                }

                if (ruleAddedEdgesChannels.containsKey(v2)) {
                    ruleAddedEdgesChannels.get(v2).add(v1);

                } else {
                    List<vertex> sendVertex = new ArrayList<vertex>();
                    sendVertex.add(v1);

                    ruleAddedEdgesChannels.put(v2, sendVertex);

                }

            }
        }

        if (message.isEmpty())

        {
            message = "Couln't add rule between " + v1 + " and " + v2 + "";

        }

        // TODO Auto-generated method stub
        return message;
    }

    public HashMap<vertex, List<vertex>> getRuleAddedEdges() {
        return ruleAddedEdges;
    }

    public void setRuleAddedEdges(HashMap<vertex, List<vertex>> ruleAddedEdges) {
        this.ruleAddedEdges = ruleAddedEdges;
    }

    public void setRuleAddedEdgesChannels(HashMap<vertex, List<vertex>> ruleAddedEdgesChannels) {
        this.ruleAddedEdgesChannels = ruleAddedEdgesChannels;
    }

    public HashMap<vertex, List<vertex>> getRuleAddedEdgesChannels() {
        return ruleAddedEdgesChannels;
    }

}