Newer
Older
.entrySet()) {
if (!adjacentsequenceListEntryValue.getKey()
.equals(sequenceListEntry.getKey())
&& !adjacentsequenceListEntryValue.getKey()
.equals(othersequenceListEntryValue.getKey())) {
if (path.get(i).getVertexList()
.contains(adjacentsequenceListEntryValue)) {
if (connectedSeq == 0 && pathBetweenSeq.size() > 0) {
for (String othersequenceListValue : othersequenceListEntryValue
.getValue()) {
List<GraphPath<String, DefaultEdge>> pathToNextValue = allPaths
.getAllPaths(othersequenceListValue, taskEndName, false,
g.vertexSet().size());
if (pathToNextValue.size() > 0)
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);
if (unOrderedSequenceList.size() > 0) {
// get path from sequence to end
for (Entry<String, ArrayList<String>> sequenceListEntry : unOrderedSequenceList.entrySet()) {
if (g.containsVertex(sequenceListEntry.getKey())) {
int noForLoop = 0;
List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(sequenceListEntry.getKey(), taskEndName, false,
g.vertexSet().size());
for (int i = 0; i < path.size(); i++) {
if (path.size() > 0 && sequenceListEntry.getValue().size() > 0) {
if (forLoopNextValues.size() > 0) {
for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
if (path.get(i).getVertexList().contains(forloopListEntry.getKey())) {
noForLoop++;
}
}
}
if (forEverLoopList.size() > 0) {
for (String forloopListEntry : forEverLoopList) {
if (path.get(i).getVertexList().contains(forloopListEntry)) {
noForLoop++;
}
}
}
if (noForLoop == 0) {
HashSet<String> endSequenceVertex = new HashSet<String>();
endSequenceVertex.add(sequenceListEntry.getKey());
if (unOrderedSequenceEdges.containsKey(taskEndName)) {
if (!unOrderedSequenceEdges.get(taskEndName).contains(sequenceListEntry.getKey())) {
unOrderedSequenceEdges.get(taskEndName).add(sequenceListEntry.getKey());
}
unOrderedSequenceEdges.put(eventName, endSequenceVertex);
// add if sequence on path of multiple for
if (forLoopNextValues.size() > 0) {
for (Entry<String, List<String>> forloopListEntry : forLoopNextValues.entrySet()) {
if (g.containsVertex(forloopListEntry.getValue().get(0))) {
List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(forloopListEntry.getValue().get(0), 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(forEntry.getKey())) {
for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
if (path.get(i).getVertexList().contains(seqEntry.getKey())) {
if (path.get(i).getVertexList().contains(seqEntry.getValue().get(seqEntry.getValue().size() - 1)))
} else {
forloopCount++;
}
for (Entry<String, ArrayList<String>> unOrderedseqEntry : unOrderedSequenceList.entrySet()) {
forloopCount++;
if (path.get(i).getVertexList().contains(unOrderedseqEntry.getKey())) {
HashSet<String> forLoopName = new HashSet<String>();
forLoopName.add(forloopListEntry.getKey());
if (unOrderedSequenceEdges.containsKey(unOrderedseqEntry.getKey())) {
if (unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).contains(forloopListEntry.getKey())) {
unOrderedSequenceEdges.get(unOrderedseqEntry.getKey()).add(forloopListEntry.getKey());
}
unOrderedSequenceEdges.put(unOrderedseqEntry.getKey(), forLoopName);
}
String forvertexName = forloopListEntry.getKey();
if (forloopCount == 0 && !g.containsEdge(taskEndName, forvertexName)) {
addedEdges.put(taskEndName, forvertexName);
if (g.containsVertex(forloopListEntry.getValue().get(1)) && forLoopNextValues.size() > 1) {
List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(forloopListEntry.getValue().get(1), taskEndName,
false, g.vertexSet().size());
if (path.size() > 0) {
for (Entry<String, List<String>> previousForLoop : forLoopNextValues.entrySet()) {
if (g.containsVertex(previousForLoop.getValue().get(0))
&& !previousForLoop.getKey().equals(forloopListEntry.getKey())) {
List<GraphPath<String, DefaultEdge>> previousForpath = allPaths
.getAllPaths(previousForLoop.getValue().get(0), 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(forEntry.getKey())
&& !forloopListEntry.getKey().equals(forEntry.getKey())) {
String forvertexName = previousForLoop.getKey();
if (forloopCount == 0
&& !g.containsEdge(taskEndName, forvertexName)) {
addedEdges.put(taskEndName, forvertexName);
}
}
}
}
}
if (!forEverLoopList.isEmpty())
for (String loopforEver : forEverLoopList) {
List<GraphPath<String, DefaultEdge>> pathforloopforever = allPaths.getAllPaths(loopforEver, taskEndName, false,
g.vertexSet().size());
if (pathforloopforever.size() > 0) {
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(previousForLoop.getValue().get(0))) {
for (Entry<String, ArrayList<String>> seqEntry : orderedSequenceList.entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(seqEntry.getKey())) {
if (pathforloopforever.get(i).getVertexList()
.contains(seqEntry.getValue().get(seqEntry.getValue().size() - 1)))
} else {
forloopCount++;
}
for (Entry<String, ArrayList<String>> unOrderedseqEntry : unOrderedSequenceList.entrySet()) {
if (pathforloopforever.get(i).getVertexList().contains(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);
}
unOrderedSequenceEdges.put(unOrderedseqEntry.getKey(), forLoopName);
if (forloopCount == 0) {
addedEdges.put(taskEndName, loopforEver);
}
}
}
}
// start activity is added as a vertex
if (currentElement.getReferenceObject() instanceof TMLADStartState) {
taskStartName = task.getName() + "__" + currentElement.getName() + "__" + currentElement.getID();
g.addVertex(taskStartName);
g.addEdge(task.getName(), taskStartName);
if (!nameIDTaskList.containsKey(currentElement.getID())) {
nameIDTaskList.put(String.valueOf(currentElement.getID()), eventName);
// the below activities are added as vertex with the required edges
// these activities can be used to check later for latency
1370
1371
1372
1373
1374
1375
1376
1377
1378
1379
1380
1381
1382
1383
1384
1385
1386
1387
1388
1389
1390
1391
1392
else if (currentElement.getReferenceObject() instanceof TMLADSendEvent
|| currentElement.getReferenceObject() instanceof TMLADWaitEvent
|| currentElement.getReferenceObject() instanceof TMLADForLoop
|| currentElement.getReferenceObject() instanceof TMLADForStaticLoop
|| currentElement.getReferenceObject() instanceof TMLADChoice
|| currentElement.getReferenceObject() instanceof TMLADForEverLoop
|| currentElement.getReferenceObject() instanceof TMLADExecI || currentElement.getReferenceObject() instanceof TMLADExecC
|| currentElement.getReferenceObject() instanceof TMLADDelay
|| currentElement.getReferenceObject() instanceof TMLADSendRequest
|| currentElement.getReferenceObject() instanceof TMLADReadRequestArg
|| currentElement.getReferenceObject() instanceof TMLADActionState
|| currentElement.getReferenceObject() instanceof TMLADDelayInterval
|| currentElement.getReferenceObject() instanceof TMLADExecCInterval
|| currentElement.getReferenceObject() instanceof TMLADExecIInterval
|| currentElement.getReferenceObject() instanceof TMLADNotifiedEvent
|| currentElement.getReferenceObject() instanceof TMLADRandom
|| currentElement.getReferenceObject() instanceof TMLADReadChannel
|| currentElement.getReferenceObject() instanceof TMLADWriteChannel
|| currentElement.getReferenceObject() instanceof TMLADSequence
|| currentElement.getReferenceObject() instanceof TMLADUnorderedSequence
|| currentElement.getReferenceObject() instanceof TMLADSelectEvt
|| currentElement.getReferenceObject() instanceof TMLADDecrypt
|| currentElement.getReferenceObject() instanceof TMLADEncrypt) {
if (activity.getPrevious(currentElement).getReferenceObject() instanceof TMLADRandom) {
preEventName = task.getName() + "__" + activity.getPrevious(currentElement).getName() + "__"
+ activity.getPrevious(currentElement).getID();
} else {
preEventName = task.getName() + "__" + activity.getPrevious(currentElement).getReferenceObject().toString() + "__"
+ activity.getPrevious(currentElement).getID();
if (!nameIDTaskList.containsKey(currentElement.getID())) {
nameIDTaskList.put(String.valueOf(currentElement.getID()), eventName);
if (g.containsVertex(preEventName)) {
g.addVertex(eventName);
g.addEdge(preEventName, eventName);
count++;
} else if ((activity.getPrevious(currentElement).getName().equals("start")) && g.containsVertex(taskStartName)) {
g.addVertex(eventName);
g.addEdge(taskStartName, eventName);
count++;
if (currentElement.getReferenceObject() instanceof TMLADSendEvent
|| currentElement.getReferenceObject() instanceof TMLADWaitEvent
|| currentElement.getReferenceObject() instanceof TMLADSendRequest
|| currentElement.getReferenceObject() instanceof TMLADActionState
|| currentElement.getReferenceObject() instanceof TMLADNotifiedEvent
|| currentElement.getReferenceObject() instanceof TMLADReadChannel
|| currentElement.getReferenceObject() instanceof TMLADWriteChannel
|| currentElement.getReferenceObject() instanceof TMLADExecI
|| currentElement.getReferenceObject() instanceof TMLADExecC
|| currentElement.getReferenceObject() instanceof TMLADDelay
|| currentElement.getReferenceObject() instanceof TMLADActionState
|| currentElement.getReferenceObject() instanceof TMLADDelayInterval
|| currentElement.getReferenceObject() instanceof TMLADExecCInterval
|| currentElement.getReferenceObject() instanceof TMLADExecIInterval
|| currentElement.getReferenceObject() instanceof TMLADDecrypt
|| currentElement.getReferenceObject() instanceof TMLADEncrypt
|| currentElement.getReferenceObject() instanceof TMLADReadRequestArg) {
allLatencyTasks.add(eventName);
if (currentElement.getReferenceObject() instanceof TMLADForEverLoop) {
forEverLoopList.add(eventName);
}
if (currentElement.getReferenceObject() instanceof TMLADSendRequest) {
if (requestsOriginDestination.containsKey(task.getName())) {
for (String destinationTask : requestsOriginDestination.get(task.getName())) {
if (requestsPorts.containsKey(destinationTask)) {
for (String portNames : requestsPorts.get(destinationTask)) {
String[] requestName = currentElement.getReferenceObject().toString().split(":");
String[] portname = requestName[1].split("[(]");
if (portname[0].replaceAll(" ", "").equals(portNames.replaceAll(" ", ""))) {
for (String destinationTaskstartname : requestsDestination.get(destinationTask)) {
if (requestEdges.containsKey(eventName)) {
if (!requestEdges.get(eventName).contains(destinationTaskstartname)) {
requestEdges.get(eventName).add(destinationTaskstartname);
}
HashSet<String> destinationTaskoriginstart = new HashSet<String>();
destinationTaskoriginstart.add(destinationTaskstartname);
requestEdges.put(eventName, destinationTaskoriginstart);
if (currentElement.getReferenceObject() instanceof TMLADSendEvent) {
if (sendEvt.containsKey(currentElement.getReferenceObject().toString().replaceAll(" ", ""))) {
List<String> recieveEvt = sendEvt.get(currentElement.getReferenceObject().toString().replaceAll(" ", ""));
for (String vertex : g.vertexSet()) {
String[] vertexName = vertex.split("__");
for (String n : recieveEvt) {
if (vertexName.length >= 3) {
if ((n.replaceAll(" ", "").equals((vertexName[2].toString().replaceAll(" ", ""))))) {
HashSet<String> waitEventVertex = new HashSet<String>();
waitEventVertex.add(vertex);
if (sendEventWaitEventEdges.containsKey(eventName)) {
if (!sendEventWaitEventEdges.get(eventName).contains(vertex)) {
sendEventWaitEventEdges.get(eventName).add(vertex);
}
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(" ", ""));
for (String vertex : g.vertexSet()) {
String[] vertexName = vertex.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)) {
if (!sendEventWaitEventEdges.get(vertex).contains(eventName)) {
sendEventWaitEventEdges.get(vertex).add(eventName);
}
sendEventWaitEventEdges.put(vertex, waitEventVertex);
}
}
}
}
if (currentElement.getReferenceObject() instanceof TMLADWriteChannel) {
String[] name = eventName.split("__");
String[] removewrite = name[2].split(":");
String[] portname = removewrite[1].split("[(]");
String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
String portNameNoSpaces = portname[0].replaceAll(" ", "");
if (sendData.containsKey(portNameNoSpaces)) {
String sendDatachannels = name[0] + "__" + portNameNoSpaces + "__" + name[0] + "__" + sendData.get(portNameNoSpaces);
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(sendDatachannels);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(sendDatachannels)) {
readWriteChannelEdges.get(eventName).add(sendDatachannels);
}
readWriteChannelEdges.put(eventName, writeChVertex);
} else {
HashSet<String> writeChVertex = new HashSet<String>();
writeChVertex.add(chwriteName);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(chwriteName)) {
readWriteChannelEdges.get(eventName).add(chwriteName);
}
readWriteChannelEdges.put(eventName, writeChVertex);
if (currentElement.getReferenceObject() instanceof TMLADReadChannel) {
String[] name = eventName.split("__");
String[] removewrite = name[2].split(":");
String[] portname = removewrite[1].split("[(]");
String chwriteName = (name[0] + "__" + portname[0]).replaceAll(" ", "");
String portNameNoSpaces = portname[0].replaceAll(" ", "");
if (receiveData.containsKey(portNameNoSpaces)) {
String sendDatachannels = name[0] + "__" + receiveData.get(portNameNoSpaces) + "__" + name[0] + "__"
+ portNameNoSpaces;
HashSet<String> readChVertex = new HashSet<String>();
readChVertex.add(sendDatachannels);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(sendDatachannels)) {
readWriteChannelEdges.get(eventName).add(sendDatachannels);
}
readWriteChannelEdges.put(eventName, readChVertex);
/*
* if (g.containsVertex(chwriteName))
*
* { g.addEdge(chwriteName, eventName); }
*/
} else {
HashSet<String> readChVertex = new HashSet<String>();
readChVertex.add(eventName);
if (readWriteChannelEdges.containsKey(eventName)) {
if (!readWriteChannelEdges.get(eventName).contains(chwriteName)) {
readWriteChannelEdges.get(eventName).add(chwriteName);
}
readWriteChannelEdges.put(chwriteName, readChVertex);
// check if the next activity :add to an array:
// in case of for loop : the first element of inside/outside branches of loop
// in case of sequence: add first element of all branches
if (currentElement.getNexts().size() == 1) {
currentElement = currentElement.getNexts().firstElement();
} else if (!multiNexts.isEmpty()) {
if (currentElement.getReferenceObject() instanceof TMLADForStaticLoop
|| currentElement.getReferenceObject() instanceof TMLADForLoop) {
if (currentElement.getNexts().size() > 1) {
List<TGConnectingPoint> points = new ArrayList<TGConnectingPoint>();
List<TGConnector> getOutputConnectors = new ArrayList<TGConnector>();
if (currentElement.getReferenceObject() instanceof TMLADForStaticLoop) {
points = Arrays.asList(((TMLADForStaticLoop) (currentElement.getReferenceObject())).getConnectingPoints());
getOutputConnectors = ((TMLADForStaticLoop) (currentElement
.getReferenceObject())).getOutputConnectors();
} else if (currentElement.getReferenceObject() instanceof TMLADForLoop) {
points = Arrays.asList(((TMLADForLoop) (currentElement.getReferenceObject())).getConnectingPoints());
getOutputConnectors = ((TMLADForLoop) (currentElement
.getReferenceObject())).getOutputConnectors();
}
TGConnector inputConnector = null, outputConnector = null;
for (TGConnector connector : getOutputConnectors) {
if (connector.getTGConnectingPointP1() == points.get(1)) {
inputConnector = connector;
} else if (connector.getTGConnectingPointP1() == points.get(2)) {
outputConnector = connector;
}
List<String> afterloopActivity = new ArrayList<String>(2);
String insideLoop = "", outsideLoop = "";
for (TMLActivityElement ae : currentElement.getNexts()) {
List<TGConnector> cg = (((TGComponent) ae.getReferenceObject()).getInputConnectors());
for (TGConnector afterloopcg : cg) {
if (afterloopcg == inputConnector) {
insideLoop = task.getName() + "__" + ae.getReferenceObject().toString() + "__" + ae.getID();
} else if (afterloopcg == outputConnector) {
outsideLoop = task.getName() + "__" + ae.getReferenceObject().toString() + "__" + ae.getID();
afterloopActivity.add(0, insideLoop);
afterloopActivity.add(1, outsideLoop);
forLoopNextValues.put(eventName, afterloopActivity);
} else if (currentElement.getReferenceObject() instanceof TMLADSequence) {
String nextEventName = "";
for (TMLActivityElement seqListnextElement : currentElement.getNexts()) {
if (seqListnextElement.getReferenceObject() instanceof TMLADRandom) {
nextEventName = task.getName() + "__" + seqListnextElement.getName() + "__" + seqListnextElement.getID();
} else {
nextEventName = task.getName() + "__" + seqListnextElement.getReferenceObject().toString() + "__"
+ seqListnextElement.getID();
if (orderedSequenceList.containsKey(eventName)) {
if (!orderedSequenceList.get(eventName).contains(nextEventName)) {
orderedSequenceList.get(eventName).add(nextEventName);
} else {
ArrayList<String> seqListNextValues = new ArrayList<String>();
seqListNextValues.add(nextEventName);
orderedSequenceList.put(eventName, seqListNextValues);
} else if (currentElement.getReferenceObject() instanceof TMLADUnorderedSequence) {
String nextEventName = "";
for (TMLActivityElement seqListnextElement : currentElement.getNexts()) {
if (seqListnextElement.getReferenceObject() instanceof TMLADRandom) {
nextEventName = task.getName() + "__" + seqListnextElement.getName() + "__" + seqListnextElement.getID();
} else {
nextEventName = task.getName() + "__" + seqListnextElement.getReferenceObject().toString() + "__"
+ seqListnextElement.getID();
if (unOrderedSequenceList.containsKey(eventName)) {
if (!unOrderedSequenceList.get(eventName).contains(nextEventName)) {
unOrderedSequenceList.get(eventName).add(nextEventName);
}
} else {
ArrayList<String> seqListNextValues = new ArrayList<String>();
seqListNextValues.add(nextEventName);
unOrderedSequenceList.put(eventName, seqListNextValues);
}
List<TGConnector> cg = (((TGComponent) currentElement.getReferenceObject()).getInputConnectors());
currentElement = multiNexts.get(0);
multiNexts.remove(0);
return cpuTaskMap;
}
// 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<String, DefaultEdge> graphAdapter = new JGraphXAdapter<String, 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<String> vertexIDProvider = new ComponentNameProvider<String>() {
@Override
public String getName(String vertex) {
// TODO Auto-generated method stub
vertex = vertex.replaceAll("\\s+", "");
vertex = vertex.replaceAll("\\(", "\\u0028");
vertex = vertex.replaceAll("\\)", "\\u0029");
return vertex;
ComponentNameProvider<String> vertexNameProvider = new ComponentNameProvider<String>() {
@Override
public String getName(String vertex) {
// TODO Auto-generated method stub
return vertex;
}
};
ComponentNameProvider<DefaultEdge> edgeIDProvider = new ComponentNameProvider<DefaultEdge>() {
@Override
public String getName(DefaultEdge edge) {
String source = g.getEdgeSource(edge).replaceAll("\\s+", "");
source = source.replaceAll("\\(", "\\u0028");
source = source.replaceAll("\\)", "\\u0029");
// .replaceAll("\\(", "");
// source.replaceAll("\\)", "");
String target = g.getEdgeTarget(edge).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<String, DefaultEdge> exporter = new GraphMLExporter<String, DefaultEdge>(vertexIDProvider, vertexNameProvider, edgeIDProvider,
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) {
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);
Vector<SimulationTransaction> Task1Traces = new Vector<SimulationTransaction>();
Vector<SimulationTransaction> Task2Traces = new Vector<SimulationTransaction>();
GraphPath<String, DefaultEdge> path2 = DijkstraShortestPath.findPathBetween(g, task12, task22);
// List<GraphPath<String, DefaultEdge>> path = allPaths.getAllPaths(task12,
// task22, false, 100);
// int size = path.size();
times1.clear();