Newer
Older
if ((n.replaceAll(" ", "").equals((vertexName[2].toString().replaceAll(" ", ""))))) {
HashSet<String> waitEventVertex = new HashSet<String>();
waitEventVertex.add(vertex.toString());
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);
2194
2195
2196
2197
2198
2199
2200
2201
2202
2203
2204
2205
2206
2207
2208
2209
2210
2211
2212
2213
2214
2215
}
// 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))))
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
2645
2646
2647
2648
2649
2650
2651
2652
/*
* 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))))
{
}
}
}
2748
2749
2750
2751
2752
2753
2754
2755
2756
2757
2758
2759
2760
2761
2762
2763
2764
2765
2766
2767
2768
2769
2770
2771
2772
/*
* 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,
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
2954
2955
2956
2957
2958
2959
2960
2961
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>();