Newer
Older
if (sendEventWaitEventEdges.containsKey(eventName)) {
if (!sendEventWaitEventEdges.get(eventName).contains(vertex.toString())) {
sendEventWaitEventEdges.get(eventName).add(vertex.toString());
sendEventWaitEventEdges.put(eventName, waitEventVertex);
if (currentElement.getReferenceObject() instanceof TMLADWaitEvent) {
if (waitEvt.containsKey(currentElement.getReferenceObject().toString().replaceAll(" ", ""))) {
List<String> sendevent = waitEvt.get(currentElement.getReferenceObject().toString().replaceAll(" ", ""));
String[] vertexName = vertex.toString().split("__");
for (String n : sendevent) {
if (vertexName.length >= 3) {
if ((n.replaceAll(" ", "").equals((vertexName[2].toString().replaceAll(" ", ""))))) {
HashSet<String> waitEventVertex = new HashSet<String>();
waitEventVertex.add(eventName);
if (sendEventWaitEventEdges.containsKey(vertex.toString())) {
if (!sendEventWaitEventEdges.get(vertex.toString()).contains(eventName)) {
sendEventWaitEventEdges.get(vertex.toString()).add(eventName);
}
sendEventWaitEventEdges.put(vertex.toString(), waitEventVertex);
if (currentElement.getReferenceObject() instanceof TMLADWriteChannel) {
String[] portname = removewrite[1].split("[(]");
String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
String portNameNoSpaces = portname[0].replaceAll(" ", "");
if (sendData.containsKey(portNameNoSpaces)) {
String sendDatachannels;
if (((TMLWriteChannel) currentElement).getChannel(0).getName().contains("FORKCHANNEL")
|| ((TMLWriteChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("FORKTASK")
|| ((TMLWriteChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("FORKTASK")
|| ((TMLWriteChannel) currentElement).getChannel(0).getName().contains("JOINCHANNEL")
|| ((TMLWriteChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("JOINTASK")
|| ((TMLWriteChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("JOINTASK")
) {
sendDatachannels = sendData.get(portNameNoSpaces);
} else {
// sendDatachannels = name[0] + "__" + sendData.get(portNameNoSpaces) + "__" +
// name[0] + "__" + portNameNoSpaces;
sendDatachannels = name[0] + "__" + portNameNoSpaces + "__" + name[0] + "__" + sendData.get(portNameNoSpaces);
}
// String sendDatachannels = name[0] + "__" + portNameNoSpaces + "__" + name[0]
// + "__" + sendData.get(portNameNoSpaces);
// if (sendDatachannels.contains("FORKPORTORIGIN")) {
// sendDatachannels= sendDatachannels.replace("FORKPORTORIGIN", "FORKCHANNEL");
//
// }
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(sendDatachannels);
if (writeReadChannelEdges.containsKey(eventName)) {
if (!writeReadChannelEdges.get(eventName).contains(sendDatachannels)) {
writeReadChannelEdges.get(eventName).add(sendDatachannels);
writeReadChannelEdges.put(eventName, writeChVertex);
}
// getvertex(sendDatachannels).setTaintFixedNumber(getvertex(sendDatachannels).getTaintFixedNumber()
// + 1);
}
else {
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(chwriteName);
if (writeReadChannelEdges.containsKey(eventName)) {
if (!writeReadChannelEdges.get(eventName).contains(chwriteName)) {
writeReadChannelEdges.get(eventName).add(chwriteName);
writeReadChannelEdges.put(eventName, writeChVertex);
// getvertex(chwriteName).setTaintFixedNumber(getvertex(chwriteName).getTaintFixedNumber()
// + 1);
}
if (currentElement.getReferenceObject() instanceof TMLADReadChannel) {
String[] portname = removewrite[1].split("[(]");
String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
String portNameNoSpaces = portname[0].replaceAll(" ", "");
if (receiveData.containsKey(portNameNoSpaces)) {
String sendDatachannels;
if (((TMLReadChannel) currentElement).getChannel(0).getName().contains("FORKCHANNEL")
|| ((TMLReadChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("FORKTASK")
|| ((TMLReadChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("FORKTASK")
|| ((TMLReadChannel) currentElement).getChannel(0).getName().contains("JOINCHANNEL")
|| ((TMLReadChannel) currentElement).getChannel(0).getDestinationTask().getName().startsWith("JOINTASK")
|| ((TMLReadChannel) currentElement).getChannel(0).getOriginTask().getName().startsWith("JOINTASK")) {
sendDatachannels = receiveData.get(portNameNoSpaces);
} else {
sendDatachannels = name[0] + "__" + receiveData.get(portNameNoSpaces) + "__" + name[0] + "__" + portNameNoSpaces;
HashSet<String> readChVertex = new HashSet<String>();
readChVertex.add(eventName);
if (readWriteChannelEdges.containsKey(sendDatachannels)) {
if (!readWriteChannelEdges.get(sendDatachannels).contains(eventName)) {
readWriteChannelEdges.get(sendDatachannels).add(eventName);
}
readWriteChannelEdges.put(sendDatachannels, readChVertex);
2186
2187
2188
2189
2190
2191
2192
2193
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
}
// getvertex(sendDatachannels).setTaintFixedNumber(getvertex(sendDatachannels).getTaintFixedNumber()
// + 1);
/*
* if (g.containsVertex(chwriteName))
*
* { g.addEdge(chwriteName, eventName); }
*/
} else {
HashSet<String> readChVertex = new HashSet<String>();
readChVertex.add(eventName);
if (readWriteChannelEdges.containsKey(chwriteName)) {
if (!readWriteChannelEdges.get(chwriteName).contains(eventName)) {
readWriteChannelEdges.get(chwriteName).add(eventName);
}
} else {
readWriteChannelEdges.put(chwriteName, readChVertex);
private void addStopVertex(String taskName) {
// TODO Auto-generated method stub
String taskEndName = "";
int taskEndid;
int preEventid;
String preEventName;
String eventName = null;
eventName = getEventName(taskName, currentElement);
taskEndid = currentElement.getID();
taskEndName = taskName + "__" + currentElement.getName() + "__" + taskEndid;
preEventid = activity.getPrevious(currentElement).getID();
if (activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADRandom) {
preEventName = taskName + "__" + activity.getPrevious(currentElement).getName() + "__" + preEventid;
} else if (currentElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
preEventName = taskName + "__" + "unOrderedSequence" + "__" + preEventid;
} else {
preEventName = taskName + "__" + activity.getPrevious(currentElement).getReferenceObject().toString() + "__" + preEventid;
vertex taskEndVertex = vertex(taskEndName, taskEndid);
g.addVertex(taskEndVertex);
// gVertecies.add(vertex(taskEndName));
getvertex(eventName).setType(vertex.TYPE_END);
getvertex(eventName).setTaintFixedNumber(1);
// allTasks.add(taskEndName);
if (!(activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADSequence)) {
g.addEdge(getvertex(preEventName), getvertex(taskEndName));
@SuppressWarnings({ "unchecked", "rawtypes" })
AllDirectedPaths<vertex, DefaultEdge> allPaths = new AllDirectedPaths<vertex, DefaultEdge>(g);
if (orderedSequenceList.size() > 0) {
int noForLoop = 0;
// get path from sequence to end
for (Entry<String, ArrayList<String>> sequenceListEntry : orderedSequenceList.entrySet()) {
if (g.containsVertex(getvertex(sequenceListEntry.getKey()))) {
List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(sequenceListEntry.getKey()), getvertex(taskEndName),
false, g.vertexSet().size());
for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList.entrySet()) {
if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
if (path.get(i).getVertexList().contains(getvertex(othersequenceListEntryValue.getKey()))) {
}
}
}
if (path.size() > 0 && sequenceListEntry.getValue().size() > 0 && directlyConnectedSeq == 0) {
for (String sequenceListEntryValue : sequenceListEntry.getValue()) {
if (g.containsVertex(getvertex(sequenceListEntryValue))) {
if (path.get(i).getVertexList().contains(getvertex(sequenceListEntryValue))) {
for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
if ((path.get(i).getVertexList().contains(getvertex(forloopListEntry.getValue().get(0)))
&& getvertex(forloopListEntry.getValue().get(0)).getName() != sequenceListEntry.getKey())
|| path.get(i).getVertexList().contains(getvertex(
sequenceListEntry.getValue().get(sequenceListEntry.getValue().size() - 1)))) {
for (String forloopListEntry : forEverLoopList) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry))) {
}
}
}
int nextIndex = sequenceListEntry.getValue().indexOf(sequenceListEntryValue) + 1;
if (nextIndex < sequenceListEntry.getValue().size()) {
HashSet<String> endSequenceVertex = new HashSet<String>();
endSequenceVertex.add(sequenceListEntry.getValue().get(nextIndex));
if (sequenceEdges.containsKey(taskEndName)) {
if (!sequenceEdges.get(taskEndName).contains(sequenceListEntry.getValue().get(nextIndex))) {
sequenceEdges.get(taskEndName).add(sequenceListEntry.getValue().get(nextIndex));
}
sequenceEdges.put(eventName, endSequenceVertex);
} else if (nextIndex == sequenceListEntry.getValue().size() && orderedSequenceList.size() > 1) {
for (Entry<String, ArrayList<String>> othersequenceListEntryValue : orderedSequenceList.entrySet()) {
if (!othersequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())) {
List<GraphPath<vertex, DefaultEdge>> pathBetweenSeq = allPaths.getAllPaths(
getvertex(othersequenceListEntryValue.getKey()), getvertex(taskEndName), false,
g.vertexSet().size());
for (int j = 0; j < pathBetweenSeq.size(); j++) {
for (Entry<String, ArrayList<String>> adjacentsequenceListEntryValue : orderedSequenceList
.entrySet()) {
if (!adjacentsequenceListEntryValue.getKey().equals(sequenceListEntry.getKey())
&& !adjacentsequenceListEntryValue.getKey()
.equals(othersequenceListEntryValue.getKey())) {
if (path.get(i).getVertexList()
.contains(getvertex(adjacentsequenceListEntryValue.getKey()))) {
if (connectedSeq == 0 && pathBetweenSeq.size() > 0) {
for (String othersequenceListValue : othersequenceListEntryValue.getValue()) {
List<GraphPath<vertex, DefaultEdge>> pathToNextValue = allPaths.getAllPaths(
getvertex(othersequenceListValue), getvertex(taskEndName), false,
g.vertexSet().size());
int nextAdjIndex = othersequenceListEntryValue.getValue()
.indexOf(othersequenceListValue) + 1;
if (nextAdjIndex < othersequenceListEntryValue.getValue().size()) {
HashSet<String> nextSequenceVertex = new HashSet<String>();
nextSequenceVertex
.add(othersequenceListEntryValue.getValue().get(nextAdjIndex));
if (sequenceEdges.containsKey(taskEndName)) {
if (!sequenceEdges.get(taskEndName).contains(
othersequenceListEntryValue.getValue().get(nextAdjIndex))) {
sequenceEdges.get(taskEndName).add(
othersequenceListEntryValue.getValue().get(nextAdjIndex));
}
sequenceEdges.put(eventName, nextSequenceVertex);
// get path from sequence to end
for (Entry<String, ArrayList<String>> sequenceListEntry : unOrderedSequenceList.entrySet()) {
if (g.containsVertex(getvertex(sequenceListEntry.getKey()))) {
List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(sequenceListEntry.getKey()), getvertex(taskEndName),
false, g.vertexSet().size());
if (path.size() > 0 && sequenceListEntry.getValue().size() > 0) {
for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry.getKey()))) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry.getValue().get(0))))
for (String forloopListEntry : forEverLoopList) {
if (path.get(i).getVertexList().contains(getvertex(forloopListEntry))) {
for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getKey()))) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getValue().get(seqEntry.getValue().size() - 1))))
// if (unOrderedSequenceEdges.containsKey(taskEndName)) {
// if
// (!unOrderedSequenceEdges.get(taskEndName).contains(sequenceListEntry.getKey()))
// {
// unOrderedSequenceEdges.get(taskEndName).add(sequenceListEntry.getKey());
// }
// unOrderedSequenceEdges.put(eventName, endSequenceVertex);
for (String seqEntry : sequenceListEntry.getValue()) {
GraphPath<vertex, DefaultEdge> pathToEnd = null;
if (g.containsVertex(getvertex(seqEntry))) {
pathToEnd = DijkstraShortestPath.findPathBetween(g, getvertex(seqEntry), getvertex(eventName));
if (pathToEnd == null) {
if (unOrderedSequenceEdges.containsKey(taskEndName)) {
if (!unOrderedSequenceEdges.get(taskEndName).contains(sequenceListEntry.getKey())) {
unOrderedSequenceEdges.get(taskEndName).add(seqEntry);
}
HashSet<String> endSequenceVertex = new HashSet<String>();
endSequenceVertex.add(seqEntry);
unOrderedSequenceEdges.put(eventName, endSequenceVertex);
for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
if (g.containsVertex(getvertex(forloopListEntry.getValue().get(0)))) {
List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(forloopListEntry.getValue().get(0)),
getvertex(taskEndName), false, g.vertexSet().size());
for (int i = 0; i < path.size(); i++) {
int forloopCount = 0;
for (Entry<String, List<String>> forEntry : forLoopNextValues.entrySet()) {
if (!forloopListEntry.getKey().equals(forEntry.getKey())) {
if (path.get(i).getVertexList().contains(getvertex(forEntry.getKey()))) {
for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getKey()))) {
if (path.get(i).getVertexList().contains(getvertex(seqEntry.getValue().get(seqEntry.getValue().size() - 1))))
2594
2595
2596
2597
2598
2599
2600
2601
2602
2603
2604
2605
2606
2607
2608
2609
2610
2611
2612
2613
2614
2615
2616
2617
2618
2619
2620
2621
2622
2623
2624
2625
2626
2627
2628
2629
2630
2631
2632
2633
2634
2635
2636
2637
2638
2639
2640
2641
2642
2643
2644
/*
* for (Entry<String, ArrayList<String>> unOrderedseqEntry :
* unOrderedSequenceList.entrySet()) {
*
* if
* (path.get(i).getVertexList().contains(getvertex(unOrderedseqEntry.getKey())))
* { forloopCount++;
*
* HashSet<String> forLoopName = new HashSet<String>();
* forLoopName.add(forloopListEntry.getKey());
*
*
* //GraphPath<vertex, DefaultEdge> pathToEnd = null;
*
* if (unOrderedSequenceEdges.containsKey(taskEndName)) {
*
* if
* (!unOrderedSequenceEdges.get(taskEndName).contains(forloopListEntry.getKey())
* ) { unOrderedSequenceEdges.get(taskEndName).add(forloopListEntry.getKey()); }
*
* } else {
*
* // HashSet<String> endSequenceVertex = new HashSet<String>(); //
* endSequenceVertex.add(unOrderedseqEntry);
*
* unOrderedSequenceEdges.put(eventName, forLoopName);
*
* }
*
*
*
* /* if (unOrderedSequenceEdges.containsKey(unOrderedseqEntry.getKey())) {
*
* if (unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).contains(
* forloopListEntry.getKey())) {
* unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).add(forloopListEntry.
* getKey()); }
*
* } else {
*
* unOrderedSequenceEdges.put(unOrderedseqEntry.getKey(), forLoopName);
*
* }
*
*
* }
*
* }
*/
String forvertexName = forloopListEntry.getKey();
if (forloopCount == 0 && !g.containsEdge(getvertex(taskEndName), getvertex(forvertexName))) {
if (g.containsVertex(getvertex(forloopListEntry.getValue().get(1))) && forLoopNextValues.size() > 1) {
List<GraphPath<vertex, DefaultEdge>> path = allPaths.getAllPaths(getvertex(forloopListEntry.getValue().get(1)),
getvertex(taskEndName), false, g.vertexSet().size());
for (Entry<String, List<String>> previousForLoop : forLoopNextValues.entrySet()) {
if (g.containsVertex(getvertex(previousForLoop.getValue().get(0)))
&& !previousForLoop.getKey().equals(forloopListEntry.getKey())) {
List<GraphPath<vertex, DefaultEdge>> previousForpath = allPaths.getAllPaths(
getvertex(previousForLoop.getValue().get(0)), getvertex(taskEndName), false, g.vertexSet().size());
for (int i = 0; i < previousForpath.size(); i++) {
int forloopCount = 0;
for (Entry<String, List<String>> forEntry : forLoopNextValues.entrySet()) {
if (previousForpath.get(i).getVertexList().contains(getvertex(forEntry.getKey()))
&& !forloopListEntry.getKey().equals(forEntry.getKey())) {
String forvertexName = previousForLoop.getKey();
if (forloopCount == 0
&& !g.containsEdge(getvertex(taskEndName), getvertex(forvertexName))) {
List<GraphPath<vertex, DefaultEdge>> pathforloopforever = allPaths.getAllPaths(getvertex(loopforEver), getvertex(taskEndName), false,
g.vertexSet().size());
for (int i = 0; i < pathforloopforever.size(); i++) {
int forloopCount = 0;
for (Entry<String, List<String>> previousForLoop : forLoopNextValues.entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(getvertex(previousForLoop.getValue().get(0)))) {
for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(getvertex(seqEntry.getKey()))) {
if (pathforloopforever.get(i).getVertexList()
.contains(getvertex(seqEntry.getValue().get(seqEntry.getValue().size() - 1))))
{
}
}
}
2740
2741
2742
2743
2744
2745
2746
2747
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
/*
* for (Entry<String, ArrayList<String>> unOrderedseqEntry :
* unOrderedSequenceList.entrySet()) {
*
* if (pathforloopforever.get(i).getVertexList().contains(getvertex(
* unOrderedseqEntry.getKey()))) { forloopCount++;
*
* HashSet<String> forLoopName = new HashSet<String>();
* forLoopName.add(loopforEver);
*
* if (unOrderedSequenceEdges.containsKey(unOrderedseqEntry.getKey())) {
*
* if
* (unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).contains(loopforEver)
* ) { unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).add(loopforEver);
* }
*
* } else {
*
* unOrderedSequenceEdges.put(unOrderedseqEntry.getKey(), forLoopName);
*
* }
*
* } }
*/
}
}
}
}
opCount++;
}
private String getEventName(String taskName, TMLActivityElement currentElement2) {
String eventName = null;
if (currentElement.getReferenceObject() instanceof TMLADRandom) {
eventName = taskName + "__" + currentElement2.getName() + "__" + currentElement2.getID();
} else if (currentElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
eventName = taskName + "__" + "unOrderedSequence" + "__" + currentElement2.getID();
} else {
eventName = taskName + "__" + currentElement2.getReferenceObject().toString() + "__" + currentElement2.getID();
}
return eventName;
}
// get graph size
public int getGraphsize() {
return g.vertexSet().size();
}
// get graph size
public int getGraphEdgeSet() {
return g.edgeSet().size();
}
// open graph in a frame
public void showGraph(DirectedGraphTranslator dgraph) {
JGraphXAdapter<vertex, DefaultEdge> graphAdapter = new JGraphXAdapter<vertex, DefaultEdge>(dgraph.getG());
mxHierarchicalLayout layout = new mxHierarchicalLayout(graphAdapter);
layout.setInterHierarchySpacing(100);
layout.setInterRankCellSpacing(100);
layout.setIntraCellSpacing(100);
layout.execute(graphAdapter.getDefaultParent());
dgraph.getScrollPane().setViewportView(new mxGraphComponent(graphAdapter));
dgraph.getScrollPane().setVisible(true);
dgraph.getScrollPane().revalidate();
dgraph.getScrollPane().repaint();
dgraph.getFrame().add(dgraph.getScrollPane());
dgraph.getFrame().pack();
dgraph.getFrame().setLocationByPlatform(true);
dgraph.getFrame().setVisible(true);
}
public JFrame getFrame() {
return frame;
}
// save graph in .graphml format
public void exportGraph(String filename) throws ExportException, IOException {
@SuppressWarnings({ "rawtypes", "unchecked" })
GraphMLExporter<String, DefaultEdge> gmlExporter = new GraphMLExporter();
ComponentNameProvider<vertex> vertexIDProvider = new ComponentNameProvider<vertex>() {
public String getName(vertex vertex) {
String name;
for (vertex v : g.vertexSet()) {
name = vertex.getName().toString().replaceAll("\\s+", "");
name = vertex.getName().replaceAll("\\(", "\\u0028");
name = vertex.getName().replaceAll("\\)", "\\u0029");
return name;
}
}
return null;
}
};
ComponentNameProvider<vertex> vertexNameProvider = new ComponentNameProvider<vertex>() {
public String getName(vertex arg0) {
for (vertex v : g.vertexSet()) {
if (v.getName().equals(arg0.getName())) {
return arg0.getName();
};
ComponentNameProvider<DefaultEdge> edgeIDProvider = new ComponentNameProvider<DefaultEdge>() {
@Override
public String getName(DefaultEdge edge) {
String source = g.getEdgeSource(edge).toString().replaceAll("\\s+", "");
source = source.replaceAll("\\(", "\\u0028");
source = source.replaceAll("\\)", "\\u0029");
// .replaceAll("\\(", "");
// source.replaceAll("\\)", "");
String target = g.getEdgeTarget(edge).toString().replaceAll("\\s+", "");
target = target.replaceAll("\\(", "\\u0028");
target = target.replaceAll("\\)", "\\u0029");
// target.replaceAll("\\(", "");
// target.replaceAll("\\)", "");
// TODO Auto-generated method stub
return source + target;
}
};
ComponentNameProvider<DefaultEdge> edgeLabelProvider = new ComponentNameProvider<DefaultEdge>() {
@Override
public String getName(DefaultEdge edge) {
// TODO Auto-generated method stub
return Double.toString(g.getEdgeWeight(edge));
}
};
GraphMLExporter<vertex, DefaultEdge> exporter = new GraphMLExporter<vertex, DefaultEdge>(vertexIDProvider, vertexNameProvider, edgeIDProvider,
2913
2914
2915
2916
2917
2918
2919
2920
2921
2922
2923
2924
2925
2926
2927
2928
2929
2930
2931
2932
2933
2934
2935
2936
2937
2938
2939
2940
2941
2942
2943
2944
2945
2946
2947
2948
2949
2950
2951
2952
2953
edgeLabelProvider);
Writer fileWriter;
FileWriter PS = new FileWriter(filename + ".graphml");
// gmlExporter.exportGraph(g, PS);
// FileWriter PS2 = new FileWriter(filename + "test.graphml");
exporter.exportGraph(g, PS);
}
// save graph frame in .png format
public void exportGraphAsImage(String filename) throws ExportException, IOException {
Container c = frame.getContentPane();
BufferedImage im = new BufferedImage(c.getWidth(), c.getHeight(), BufferedImage.TYPE_INT_ARGB);
c.paint(im.getGraphics());
ImageIO.write(im, "PNG", new File(filename + ".png"));
}
// return all vertices that can be checked for latency
// used to fill drop down
public Vector<String> getLatencyVertices() {
return allLatencyTasks;
}
public static boolean isNumeric(String strNum) {
try {
double d = Double.parseDouble(strNum);
} catch (NumberFormatException | NullPointerException nfe) {
return false;
}
return true;
}
// fill the main table of the latency frame by checking all the delay times
// between the selected tasks
public Object[][] latencyDetailedAnalysis(String task12ID, String task22ID, Vector<SimulationTransaction> transFile1, Boolean taint,
Boolean considerAddedRules) {
for (vertex v : g.vertexSet()) {
v.setLabel(new ArrayList<String>());
v.setMaxTaintFixedNumber(new HashMap<String, Integer>());
v.setTaintConsideredNumber(new HashMap<String, Integer>());
v.setVirtualLengthAdded(0);
v.setSampleNumber(0);
}
transFile = transFile1;
// AllDirectedPaths<String, DefaultEdge> allPaths = new AllDirectedPaths<String,
// DefaultEdge>(g);
String message = "";
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);
Vector<SimulationTransaction> Task1Traces = new Vector<SimulationTransaction>();
Vector<SimulationTransaction> Task2Traces = new Vector<SimulationTransaction>();
HashMap<String, Vector<String>> Task1TaintedTraces = new LinkedHashMap<String, Vector<String>>();
HashMap<String, Vector<String>> Task2TaintedTraces = new LinkedHashMap<String, Vector<String>>();
GraphPath<vertex, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, v1, getvertex(task22));
// List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(task12,
// task22, false, 100);