diff --git a/src/main/java/tmltranslator/patternhandling/AttributeTaskJsonFile.java b/src/main/java/tmltranslator/patternhandling/AttributeTaskJsonFile.java
index 158688d5e2fb9b1b4a547e96162032c28675c9e2..bd9f992b59f12720e673a15f0f793fda649aa13d 100644
--- a/src/main/java/tmltranslator/patternhandling/AttributeTaskJsonFile.java
+++ b/src/main/java/tmltranslator/patternhandling/AttributeTaskJsonFile.java
@@ -8,7 +8,6 @@ package tmltranslator.patternhandling;
* @version 1.0 28/08/2023
*/
-import myutil.TraceManager;
import tmltranslator.*;
diff --git a/src/main/java/tmltranslator/patternhandling/MappingPatternChannel.java b/src/main/java/tmltranslator/patternhandling/MappingPatternChannel.java
index e04822314d64d40889d3b4a80941e6af9a0ab753..8b9b18c66a1d13148f2808ae087d6b6850655749 100644
--- a/src/main/java/tmltranslator/patternhandling/MappingPatternChannel.java
+++ b/src/main/java/tmltranslator/patternhandling/MappingPatternChannel.java
@@ -1,6 +1,6 @@
package tmltranslator.patternhandling;
/**
- * Class MappingPatternTask
+ * Class MappingPatternChannel
*
* Creation: 25/10/2023
*
@@ -8,23 +8,35 @@ package tmltranslator.patternhandling;
* @version 1.0 25/10/2023
*/
-import myutil.TraceManager;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
import tmltranslator.*;
public class MappingPatternChannel {
+
+ public final static String TASK_CHANNEL_SEPARATOR = "::";
+ public final static String MAP_CHANNEL_IN_SAME_MEMORY_SEPARATOR = " mapped in the same Memory as ";
+ public final static String MAP_CHANNEL_IN_NEW_MEMORY_SEPARATOR = " mapped in a new memory linked to ";
+ public final static int ORIGIN_PATTERN = 0;
+ public final static int ORIGIN_CLONE = 1;
+ public final static int ORIGIN_MODEL = 2;
+
String taskOfChannelToMap;
String channelToMapName;
+ int origin;
String taskOfChannelInSameMem;
String channelInSameMemAs;
+ int sameMemAsOrigin;
String busNameForNewMem;
+
- public MappingPatternChannel(String taskOfChannelToMap, String channelToMapName, String taskOfChannelInSameMem, String channelInSameMemAs, String busNameForNewMem) {
+ public MappingPatternChannel(String taskOfChannelToMap, String channelToMapName, int origin) {
this.taskOfChannelToMap = taskOfChannelToMap;
this.channelToMapName = channelToMapName;
- this.taskOfChannelInSameMem = taskOfChannelInSameMem;
- this.channelInSameMemAs = channelInSameMemAs;
- this.busNameForNewMem = busNameForNewMem;
+ this.origin = origin;
}
public String getTaskOfChannelToMap() {
@@ -47,6 +59,13 @@ public class MappingPatternChannel {
return busNameForNewMem;
}
+ public int getOrigin() {
+ return origin;
+ }
+
+ public int getSameMemAsOrigin() {
+ return sameMemAsOrigin;
+ }
public void setTaskOfChannelToMap(String _taskOfChannelToMap) {
taskOfChannelToMap = _taskOfChannelToMap;
@@ -56,17 +75,93 @@ public class MappingPatternChannel {
channelToMapName = _channelToMapName;
}
- public void setTaskOfChannelInSameMem(String _taskOfChannelInSameMem) {
+ public void setTaskAndChannelInSameMem(String _taskOfChannelInSameMem, String _channelInSameMemAs, int _sameMemAsOrigin) {
taskOfChannelInSameMem = _taskOfChannelInSameMem;
- }
-
- public void setChannelInSameMemAs(String _channelInSameMemAs) {
channelInSameMemAs = _channelInSameMemAs;
+ sameMemAsOrigin = _sameMemAsOrigin;
+ busNameForNewMem = null;
}
public void setBusNameForNewMem(String _busNameForNewMem) {
busNameForNewMem = _busNameForNewMem;
+ channelInSameMemAs = null;
+ taskOfChannelInSameMem = null;
}
-
+ public String getStringDisplay() {
+ if (channelInSameMemAs != null) {
+ return (taskOfChannelToMap + TASK_CHANNEL_SEPARATOR + channelToMapName + MAP_CHANNEL_IN_SAME_MEMORY_SEPARATOR + taskOfChannelInSameMem + TASK_CHANNEL_SEPARATOR + channelInSameMemAs);
+ } else {
+ return (taskOfChannelToMap + TASK_CHANNEL_SEPARATOR + channelToMapName + MAP_CHANNEL_IN_NEW_MEMORY_SEPARATOR + busNameForNewMem);
+ }
+ }
+
+ public void setOrigin(int _origin) {
+ origin = _origin;
+ }
+
+ public String getTaskChannelToMap() {
+ return (taskOfChannelToMap + TASK_CHANNEL_SEPARATOR + channelToMapName);
+ }
+
+ public String getTaskChannelInSameMem() {
+ return (taskOfChannelInSameMem + TASK_CHANNEL_SEPARATOR + channelInSameMemAs);
+ }
+
+ public static String getTaskChannel(String task, String channel) {
+ return (task + TASK_CHANNEL_SEPARATOR + channel);
+ }
+
+ public static String[] seperateTaskAndChannel(String st) {
+ String[] split = st.split(TASK_CHANNEL_SEPARATOR);
+ String task, channel;
+ if (split.length == 2) {
+ task = split[0];
+ channel = split[1];
+ return new String[]{task, channel};
+ } else {
+ return null;
+ }
+ }
+
+ public static List<MappingPatternChannel> getChannelsToMap(List<PatternConnection> patternConnectionList, LinkedHashMap<String, TaskPattern> patternTasks, List<PatternCloneTask> patternCloneTasks) {
+ List<MappingPatternChannel> mappingPatternChannels = new ArrayList<MappingPatternChannel>();
+ List<String> clonedTasks = new ArrayList<String>();
+ for (PatternCloneTask clonedTask: patternCloneTasks) {
+ clonedTasks.add(clonedTask.getClonedTask());
+ }
+ for (PatternConnection patternConnection: patternConnectionList) {
+ if (!patternConnection.isNewPort() && clonedTasks.contains(patternConnection.getModelTaskName())) {
+ MappingPatternChannel mappingPatternChannel = new MappingPatternChannel(patternConnection.getModelTaskName(), patternConnection.getModelChannelName(), ORIGIN_CLONE);
+ if (!mappingPatternChannels.contains(mappingPatternChannel)) {
+ mappingPatternChannels.add(mappingPatternChannel);
+ }
+ }
+ if (patternConnection.isANewChannelRequired(patternConnectionList, patternTasks, patternCloneTasks)) {
+ if (!patternConnection.isNewPort() && clonedTasks.contains(patternConnection.getModelTaskName())) {
+ } else {
+ for (PortTaskJsonFile portTaskJsonFile : patternTasks.get(patternConnection.getPatternTaskName()).getExternalPorts()) {
+ if (portTaskJsonFile.getType().equals(PatternCreation.CHANNEL) && patternConnection.getPatternChannel().equals(portTaskJsonFile.getName())) {
+ MappingPatternChannel mappingPatternChannel = new MappingPatternChannel(patternConnection.getPatternTaskName(), patternConnection.getPatternChannel(), ORIGIN_PATTERN);
+ if (!mappingPatternChannels.contains(mappingPatternChannel)) {
+ mappingPatternChannels.add(mappingPatternChannel);
+ }
+ }
+ }
+ }
+ }
+ }
+ for (String st : patternTasks.keySet()) {
+ for (PortTaskJsonFile portTaskJsonFile : patternTasks.get(st).getInternalPorts()) {
+ if (portTaskJsonFile.getType().equals(PatternCreation.CHANNEL) && portTaskJsonFile.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ MappingPatternChannel mappingPatternChannel = new MappingPatternChannel(st, portTaskJsonFile.getName(), ORIGIN_PATTERN);
+ if (!mappingPatternChannels.contains(mappingPatternChannel)) {
+ mappingPatternChannels.add(mappingPatternChannel);
+ }
+ }
+ }
+ }
+
+ return mappingPatternChannels;
+ }
}
diff --git a/src/main/java/tmltranslator/patternhandling/MappingPatternTask.java b/src/main/java/tmltranslator/patternhandling/MappingPatternTask.java
index b21910d89e52e2b87b78ff3966def9db6aae7390..96570ef84ab3b71434a3f424aec9915a5c90bc56 100644
--- a/src/main/java/tmltranslator/patternhandling/MappingPatternTask.java
+++ b/src/main/java/tmltranslator/patternhandling/MappingPatternTask.java
@@ -8,19 +8,26 @@ package tmltranslator.patternhandling;
* @version 1.0 25/10/2023
*/
-import myutil.TraceManager;
import tmltranslator.*;
public class MappingPatternTask {
+
+ public final static String MAP_TASK_IN_SAME_HW_SEPARATOR = " mapped in the same HW as ";
+ public final static String MAP_TASK_IN_NEW_HW_SEPARATOR = " mapped in a new HW linked to ";
+ public final static int ORIGIN_PATTERN = 0;
+ public final static int ORIGIN_CLONE = 1;
+ public final static int ORIGIN_MODEL = 2;
+
String taskToMapName;
String sameHwAs;
+ int sameHwAsOrigin;
String busNameForNewHw;
+ int origin;
- public MappingPatternTask(String taskToMapName, String sameHwAs, String busNameForNewHw) {
+ public MappingPatternTask(String taskToMapName, int origin) {
this.taskToMapName = taskToMapName;
- this.sameHwAs = sameHwAs;
- this.busNameForNewHw = busNameForNewHw;
+ this.origin = origin;
}
public String getTaskToMapName() {
@@ -35,18 +42,40 @@ public class MappingPatternTask {
return busNameForNewHw;
}
+ public int getOrigin() {
+ return origin;
+ }
+
+ public int getSameHwAsOrigin() {
+ return sameHwAsOrigin;
+ }
public void setTaskToMapName(String _taskToMapName) {
taskToMapName = _taskToMapName;
}
- public void setSameHwAs(String _sameHwAs) {
+ public void setSameHwAs(String _sameHwAs, int _sameHwAsOrigin) {
sameHwAs = _sameHwAs;
+ sameHwAsOrigin = _sameHwAsOrigin;
+ busNameForNewHw = null;
}
public void setBusNameForNewHw(String _busNameForNewHw) {
busNameForNewHw = _busNameForNewHw;
+ sameHwAs = null;
+ sameHwAsOrigin = -1;
+ }
+
+ public void setOrigin(int _origin) {
+ origin = _origin;
}
+ public String getStringDisplay() {
+ if (sameHwAs != null) {
+ return (taskToMapName + MAP_TASK_IN_SAME_HW_SEPARATOR + sameHwAs);
+ } else {
+ return (taskToMapName + MAP_TASK_IN_NEW_HW_SEPARATOR + busNameForNewHw);
+ }
+ }
}
diff --git a/src/main/java/tmltranslator/patternhandling/PatternAttributeUpdate.java b/src/main/java/tmltranslator/patternhandling/PatternAttributeUpdate.java
index fdb34ca84e713d4d0ed514ceca23ecdeda6c01a2..7d48b72c34187621cf50f0f3043f312af6f5b46d 100644
--- a/src/main/java/tmltranslator/patternhandling/PatternAttributeUpdate.java
+++ b/src/main/java/tmltranslator/patternhandling/PatternAttributeUpdate.java
@@ -1,6 +1,6 @@
package tmltranslator.patternhandling;
/**
- * Class MappingPatternTask
+ * Class PatternAttributeUpdate
*
* Creation: 25/10/2023
*
@@ -8,7 +8,6 @@ package tmltranslator.patternhandling;
* @version 1.0 25/10/2023
*/
-import myutil.TraceManager;
import tmltranslator.*;
diff --git a/src/main/java/tmltranslator/patternhandling/PatternChannelWithSecurity.java b/src/main/java/tmltranslator/patternhandling/PatternChannelWithSecurity.java
new file mode 100644
index 0000000000000000000000000000000000000000..846f23d9eb7daa58046913b05388f5eba3d9b8c7
--- /dev/null
+++ b/src/main/java/tmltranslator/patternhandling/PatternChannelWithSecurity.java
@@ -0,0 +1,72 @@
+package tmltranslator.patternhandling;
+/**
+ * Class PatternChannelWithSecurity
+ *
+ * Creation: 25/10/2023
+ *
+ * @author Jawher JERRAY
+ * @version 1.0 25/10/2023
+ */
+
+import tmltranslator.*;
+
+
+public class PatternChannelWithSecurity {
+ public static final int NO_AUTHENTICITY = 0;
+ public static final int WEAK_AUTHENTICITY = 1;
+ public static final int STRONG_AUTHENTICITY = 2;
+
+ String channelTaskName;
+ String channelName;
+ String channelMode;
+ Boolean isConf;
+ int auth;
+
+ public PatternChannelWithSecurity(String channelTaskName, String channelName, String channelMode) {
+ this.channelTaskName = channelTaskName;
+ this.channelName = channelName;
+ this.channelMode = channelMode;
+ }
+
+ public String getChannelTaskName() {
+ return channelTaskName;
+ }
+
+ public String getChannelName() {
+ return channelName;
+ }
+
+ public String getChannelMode() {
+ return channelMode;
+ }
+
+ public Boolean isConfidential() {
+ return isConf;
+ }
+
+ public int getAuthenticity() {
+ return auth;
+ }
+
+ public void setChannelTaskName(String _channelTaskName) {
+ channelTaskName = _channelTaskName;
+ }
+
+ public void setChannelName(String _channelName) {
+ channelName = _channelName;
+ }
+
+ public void setChannelMode(String _channelMode) {
+ channelMode = _channelMode;
+ }
+
+ public void setIsConfidential(Boolean _isConf) {
+ isConf = _isConf;
+ }
+
+ public void setAuthenticity(int _auth) {
+ auth = _auth;
+ }
+
+
+}
diff --git a/src/main/java/tmltranslator/patternhandling/PatternCloneTask.java b/src/main/java/tmltranslator/patternhandling/PatternCloneTask.java
index 786e1ffda9e905791b8e719d3156a4219f13f265..340c2bb021ca7a36768397014fcd3d1d7d2c6cc4 100644
--- a/src/main/java/tmltranslator/patternhandling/PatternCloneTask.java
+++ b/src/main/java/tmltranslator/patternhandling/PatternCloneTask.java
@@ -8,11 +8,12 @@ package tmltranslator.patternhandling;
* @version 1.0 25/10/2023
*/
-import myutil.TraceManager;
import tmltranslator.*;
public class PatternCloneTask {
+ public final static String CLONE_TASK_SEPARATOR = " clone of ";
+
String clonedTask;
String taskToClone;
@@ -25,7 +26,7 @@ public class PatternCloneTask {
return clonedTask;
}
- public String getSameHwAs() {
+ public String getTaskToClone() {
return taskToClone;
}
@@ -37,5 +38,10 @@ public class PatternCloneTask {
public void setTaskToClone(String _taskToClone) {
taskToClone = _taskToClone;
}
+
+ public String getStringDisplay() {
+ return (clonedTask + CLONE_TASK_SEPARATOR + taskToClone);
+
+ }
}
diff --git a/src/main/java/tmltranslator/patternhandling/PatternConfig2Json.java b/src/main/java/tmltranslator/patternhandling/PatternConfig2Json.java
index 5749691e849c26eb4d4ebfa13b8d6697c6949686..3a0eabb1af88aa3618d771f8758cb4363b67b173 100644
--- a/src/main/java/tmltranslator/patternhandling/PatternConfig2Json.java
+++ b/src/main/java/tmltranslator/patternhandling/PatternConfig2Json.java
@@ -8,42 +8,41 @@ package tmltranslator.patternhandling;
* @version 1.0 05/09/2023
*/
-import myutil.FileUtils;
-import myutil.TraceManager;
-import rationals.properties.isNormalized;
import tmltranslator.*;
-import ui.window.JDialogPatternHandling;
-import ui.window.TraceData;
-import java.io.File;
import java.io.FileWriter;
import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Path;
-import java.nio.file.Paths;
import java.util.*;
-import java.util.Map.Entry;
-import javax.swing.JDialog;
-
-import org.apache.batik.anim.timing.Trace;
import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
public class PatternConfig2Json {
+ public final static String TASK_MAPPING_ORIGIN = "Origin";
+ public final static String TASK_MAPPING_ORIGIN_PATTERN = "Pattern";
+ public final static String TASK_MAPPING_ORIGIN_CLONE = "Clone";
+ public final static String TASK_MAPPING_ORIGIN_MODEL = "Model";
public final static String TASK_MAPPING = "Task_Mapping";
public final static String TASK_TO_MAP = "Task_To_Map";
public final static String TASK_MAPPED_IN_SAME_HW_AS = "Task_Mapped_In_Same_HW_As";
+ public final static String TASK_MAPPED_IN_SAME_HW_AS_ORIGIN = "Origin_Task_Mapped_In_Same_HW_As";
public final static String TASK_MAPPED_IN_NEW_HW_CONNECTED_TO_BUS = "Task_Mapped_In_New_HW";
+ public final static String CHANNEL_MAPPING_ORIGIN = "Origin";
+ public final static String CHANNEL_MAPPING_ORIGIN_PATTERN = "Pattern";
+ public final static String CHANNEL_MAPPING_ORIGIN_CLONE = "Clone";
+ public final static String CHANNEL_MAPPING_ORIGIN_MODEL = "Model";
public final static String CHANNEL_MAPPING = "Channel_Mapping";
public final static String TASK_OF_CHANNEL_TO_MAP = "Task_Of_Channel_To_Map";
public final static String CHANNEL_TO_MAP = "Channel_To_Map";
public final static String CHANNEL_MAPPED_IN_SAME_MEM_AS = "Channel_Mapped_In_Same_Mem_As";
public final static String TASK_OF_CHANNEL_SAME_MEM = "Task_Of_Channel_Same_Mem_As";
+ public final static String CHANNEL_MAPPED_IN_SAME_MEM_AS_ORIGIN = "Origin_Channel_Mapped_In_Same_Mem_As";
public final static String CHANNEL_MAPPED_IN_NEW_MEM_CONNECTED_TO_BUS = "Channel_Mapped_In_New_Mem";
public final static String CHANNEL_CONFIG = "Channel_Configuration";
@@ -136,13 +135,13 @@ public class PatternConfig2Json {
}
- JSONArray addClonedTasksInJsonFile(LinkedHashMap<String, String> _clonedTasks) {
+ JSONArray addClonedTasksInJsonFile(List<PatternCloneTask> _clonedTasks) {
JSONArray ja = new JSONArray();
try {
- for (String clone : _clonedTasks.keySet()) {
+ for (PatternCloneTask cloneTask : _clonedTasks) {
JSONObject jo = new JSONObject();
- jo.put(CLONE_OF_TASK, clone);
- jo.put(CLONED_TASK, _clonedTasks.get(clone));
+ jo.put(CLONE_OF_TASK, cloneTask.getTaskToClone());
+ jo.put(CLONED_TASK, cloneTask.getClonedTask());
ja.put(jo);
}
} catch (JSONException e) {
@@ -151,32 +150,30 @@ public class PatternConfig2Json {
return ja;
}
- LinkedHashMap<String, String> getClonedTasksFromJsonFile(JSONArray ja) {
- LinkedHashMap<String, String> _clonedTasks = new LinkedHashMap<String, String>();
-
+ List<PatternCloneTask> getClonedTasksFromJsonFile(JSONArray ja) {
+ List<PatternCloneTask> _clonedTasks = new ArrayList<PatternCloneTask>();
for (int j = 0; j < ja.length(); j++) {
String cloneOfTask = ja.getJSONObject(j).getString(CLONE_OF_TASK);
String clonedTask = ja.getJSONObject(j).getString(CLONED_TASK);
- _clonedTasks.put(cloneOfTask, clonedTask);
+ PatternCloneTask cloneTask = new PatternCloneTask(clonedTask, cloneOfTask);
+ _clonedTasks.add(cloneTask);
}
return _clonedTasks;
}
- JSONArray addPortsConfigurationInJsonFile(LinkedHashMap<String, List<Entry<String, String>>> _portsConfig) {
+ JSONArray addPortsConfigurationInJsonFile(List<PatternPortsConfig> _portsConfig) {
JSONArray ja = new JSONArray();
try {
- for (String task : _portsConfig.keySet()) {
- for (Entry<String, String> portConf : _portsConfig.get(task)) {
- JSONObject jo = new JSONObject();
- jo.put(CHANNEL_TO_CONFIG, portConf.getKey());
- jo.put(TASK_OF_CHANNEL_TO_CONFIG, task);
- if (portConf.getValue().equals("")) {
- jo.put(CHANNEL_TO_REMOVE, "true");
- } else {
- jo.put(CHANNEL_TO_REMOVE, portConf.getValue());
- }
- ja.put(jo);
- }
+ for (PatternPortsConfig portConfig : _portsConfig) {
+ JSONObject jo = new JSONObject();
+ jo.put(CHANNEL_TO_CONFIG, portConfig.getChannelToConfig());
+ jo.put(TASK_OF_CHANNEL_TO_CONFIG, portConfig.getTaskOfChannelToConfig());
+ if (portConfig.isChannelToRemove()) {
+ jo.put(CHANNEL_TO_REMOVE, "true");
+ } else {
+ jo.put(CHANNEL_TO_MERGE_WITH, portConfig.getMergeWith());
+ }
+ ja.put(jo);
}
} catch (JSONException e) {
e.printStackTrace();
@@ -184,56 +181,51 @@ public class PatternConfig2Json {
return ja;
}
- LinkedHashMap<String, List<Entry<String, String>>> getPortsConfigurationFromJsonFile(JSONArray ja) {
- LinkedHashMap<String, List<Entry<String, String>>> _portsConfig = new LinkedHashMap<String, List<Entry<String, String>>>();
+ List<PatternPortsConfig> getPortsConfigurationFromJsonFile(JSONArray ja) {
+ List<PatternPortsConfig> _portsConfig = new ArrayList<PatternPortsConfig>();
for (int j = 0; j < ja.length(); j++) {
String taskOfChToConfig = ja.getJSONObject(j).getString(TASK_OF_CHANNEL_TO_CONFIG);
String chToConfig = ja.getJSONObject(j).getString(CHANNEL_TO_CONFIG);
- String chToMergeWith = "";
+ PatternPortsConfig portConfig = new PatternPortsConfig(taskOfChToConfig, chToConfig);
if (ja.getJSONObject(j).has(CHANNEL_TO_MERGE_WITH)) {
- chToMergeWith = ja.getJSONObject(j).getString(CHANNEL_TO_MERGE_WITH);
- }
- String chToRemove = "";
- if (ja.getJSONObject(j).has(CHANNEL_TO_REMOVE)) {
- chToRemove = ja.getJSONObject(j).getString(CHANNEL_TO_REMOVE);
- }
- if (_portsConfig.containsKey(taskOfChToConfig)) {
- if (chToMergeWith != "") {
- _portsConfig.get(taskOfChToConfig).add(new AbstractMap.SimpleEntry<String, String>(chToConfig, chToMergeWith));
- } else if (chToRemove != "") {
- _portsConfig.get(taskOfChToConfig).add(new AbstractMap.SimpleEntry<String, String>(chToConfig, ""));
- }
- } else {
- List<Entry<String, String>> portConf = new ArrayList<Entry<String, String>>();
- if (chToMergeWith != "") {
- portConf.add(new AbstractMap.SimpleEntry<String, String>(chToConfig, chToMergeWith));
- } else if (chToRemove != "") {
- portConf.add(new AbstractMap.SimpleEntry<String, String>(chToConfig, ""));
- }
- _portsConfig.put(taskOfChToConfig, portConf);
+ portConfig.setMergeWith(ja.getJSONObject(j).getString(CHANNEL_TO_MERGE_WITH));
+ }else if (ja.getJSONObject(j).has(CHANNEL_TO_REMOVE)) {
+ portConfig.setIsChannelToRemove(true);
}
+ _portsConfig.add(portConfig);
}
return _portsConfig;
}
- JSONArray addChannelsMappingInJsonFile(LinkedHashMap<String, List<String[]>> _channelsMapping) {
+ JSONArray addChannelsMappingInJsonFile(List<MappingPatternChannel> _channelsMapping) {
JSONArray ja = new JSONArray();
try {
- for (String task : _channelsMapping.keySet()) {
- for (String[] chMapping : _channelsMapping.get(task)) {
- JSONObject jo = new JSONObject();
- jo.put(CHANNEL_TO_MAP, chMapping[1]);
- jo.put(TASK_OF_CHANNEL_TO_MAP, task);
- if (chMapping[0].equals(JDialogPatternHandling.SAME_MEMORY)) {
- jo.put(CHANNEL_MAPPED_IN_SAME_MEM_AS,chMapping[3]);
- jo.put(TASK_OF_CHANNEL_SAME_MEM, chMapping[2]);
- }
- if (chMapping[0].equals(JDialogPatternHandling.NEW_MEMORY)) {
- jo.put(CHANNEL_MAPPED_IN_NEW_MEM_CONNECTED_TO_BUS,chMapping[2]);
+ for (MappingPatternChannel channelMapping : _channelsMapping) {
+ JSONObject jo = new JSONObject();
+ jo.put(CHANNEL_TO_MAP, channelMapping.getChannelToMapName());
+ jo.put(TASK_OF_CHANNEL_TO_MAP, channelMapping.getTaskOfChannelToMap());
+ if (channelMapping.getOrigin() == MappingPatternChannel.ORIGIN_CLONE) {
+ jo.put(CHANNEL_MAPPING_ORIGIN, CHANNEL_MAPPING_ORIGIN_CLONE);
+ } else if (channelMapping.getOrigin() == MappingPatternChannel.ORIGIN_PATTERN) {
+ jo.put(CHANNEL_MAPPING_ORIGIN, CHANNEL_MAPPING_ORIGIN_PATTERN);
+ } else if (channelMapping.getOrigin() == MappingPatternChannel.ORIGIN_MODEL) {
+ jo.put(CHANNEL_MAPPING_ORIGIN, CHANNEL_MAPPING_ORIGIN_MODEL);
+ }
+ if (channelMapping.getChannelInSameMemAs() != null && channelMapping.getTaskOfChannelInSameMem() != null) {
+ jo.put(CHANNEL_MAPPED_IN_SAME_MEM_AS, channelMapping.getChannelInSameMemAs());
+ jo.put(TASK_OF_CHANNEL_SAME_MEM, channelMapping.getTaskOfChannelInSameMem());
+ if (channelMapping.getSameMemAsOrigin() == MappingPatternChannel.ORIGIN_CLONE) {
+ jo.put(CHANNEL_MAPPED_IN_SAME_MEM_AS_ORIGIN, CHANNEL_MAPPING_ORIGIN_CLONE);
+ } else if (channelMapping.getSameMemAsOrigin() == MappingPatternChannel.ORIGIN_PATTERN) {
+ jo.put(CHANNEL_MAPPED_IN_SAME_MEM_AS_ORIGIN, CHANNEL_MAPPING_ORIGIN_PATTERN);
+ } else if (channelMapping.getSameMemAsOrigin() == MappingPatternChannel.ORIGIN_MODEL) {
+ jo.put(CHANNEL_MAPPED_IN_SAME_MEM_AS_ORIGIN, CHANNEL_MAPPING_ORIGIN_MODEL);
}
- ja.put(jo);
}
-
+ if (channelMapping.getBusNameForNewMem() != null) {
+ jo.put(CHANNEL_MAPPED_IN_NEW_MEM_CONNECTED_TO_BUS, channelMapping.getBusNameForNewMem());
+ }
+ ja.put(jo);
}
} catch (JSONException e) {
e.printStackTrace();
@@ -260,20 +252,27 @@ public class PatternConfig2Json {
return ja;
}
- JSONArray addChannelsWithSecurityInJsonFile(LinkedHashMap<String, List<PortTaskJsonFile>> _channelsWithSec) {
+ JSONArray addChannelsWithSecurityInJsonFile(List<PatternChannelWithSecurity> _channelsWithSec) {
JSONArray ja = new JSONArray();
try {
- for (String task : _channelsWithSec.keySet()) {
- for (PortTaskJsonFile portTask : _channelsWithSec.get(task)) {
- JSONObject jo = new JSONObject();
- jo.put(TASK_CHANNEL_WITH_SECURITY_NAME, task);
- jo.put(PatternCreation.NAME, portTask.getName());
- jo.put(PatternCreation.TYPE, portTask.getType());
- jo.put(PatternCreation.MODE, portTask.getMode());
- jo.put(PatternCreation.CONFIDENTIALITY, portTask.getConfidentiality());
- jo.put(PatternCreation.AUTHENTICITY, portTask.getAuthenticity());
- ja.put(jo);
+ for (PatternChannelWithSecurity channelWithSec : _channelsWithSec) {
+ JSONObject jo = new JSONObject();
+ jo.put(TASK_CHANNEL_WITH_SECURITY_NAME, channelWithSec.getChannelTaskName());
+ jo.put(PatternCreation.NAME, channelWithSec.getChannelName());
+ jo.put(PatternCreation.MODE, channelWithSec.getChannelMode());
+ if (channelWithSec.isConfidential()) {
+ jo.put(PatternCreation.CONFIDENTIALITY, PatternCreation.WITH_CONFIDENTIALITY);
+ } else {
+ jo.put(PatternCreation.CONFIDENTIALITY, PatternCreation.WITHOUT_CONFIDENTIALITY);
+ }
+ if (channelWithSec.getAuthenticity() == PatternChannelWithSecurity.NO_AUTHENTICITY) {
+ jo.put(PatternCreation.AUTHENTICITY, PatternCreation.WITHOUT_AUTHENTICITY);
+ } else if (channelWithSec.getAuthenticity() == PatternChannelWithSecurity.WEAK_AUTHENTICITY) {
+ jo.put(PatternCreation.AUTHENTICITY, PatternCreation.WEAK_AUTHENTICITY);
+ } else if (channelWithSec.getAuthenticity() == PatternChannelWithSecurity.STRONG_AUTHENTICITY) {
+ jo.put(PatternCreation.AUTHENTICITY, PatternCreation.STRONG_AUTHENTICITY);
}
+ ja.put(jo);
}
} catch (JSONException e) {
e.printStackTrace();
@@ -281,28 +280,29 @@ public class PatternConfig2Json {
return ja;
}
- LinkedHashMap<String, List<PortTaskJsonFile>> getChannelsWithSecurityFromJsonFile(JSONArray ja) {
- LinkedHashMap<String, List<PortTaskJsonFile>> _channelsWithSec = new LinkedHashMap<String, List<PortTaskJsonFile>>();
+ List<PatternChannelWithSecurity> getChannelsWithSecurityFromJsonFile(JSONArray ja) {
+ List<PatternChannelWithSecurity> _channelsWithSec = new ArrayList<PatternChannelWithSecurity>();
for (int j = 0; j < ja.length(); j++) {
String taskName = ja.getJSONObject(j).getString(TASK_CHANNEL_WITH_SECURITY_NAME);
String channelName = ja.getJSONObject(j).getString(PatternCreation.NAME);
- String channelType = ja.getJSONObject(j).getString(PatternCreation.TYPE);
String channelMode = ja.getJSONObject(j).getString(PatternCreation.MODE);
String channelConf = ja.getJSONObject(j).getString(PatternCreation.CONFIDENTIALITY);
String channelAuth = ja.getJSONObject(j).getString(PatternCreation.AUTHENTICITY);
- if (_channelsWithSec.containsKey(taskName)) {
- PortTaskJsonFile portTask = new PortTaskJsonFile(channelName, channelType, channelMode);
- portTask.setConfidentiality(channelConf);
- portTask.setAuthenticity(channelAuth);
- _channelsWithSec.get(taskName).add(portTask);
- } else {
- List<PortTaskJsonFile> listPortTask = new ArrayList<PortTaskJsonFile>();
- PortTaskJsonFile portTask = new PortTaskJsonFile(channelName, channelType, channelMode);
- portTask.setConfidentiality(channelConf);
- portTask.setAuthenticity(channelAuth);
- listPortTask.add(portTask);
- _channelsWithSec.put(taskName, listPortTask);
+ PatternChannelWithSecurity channelWithSecurity = new PatternChannelWithSecurity(taskName, channelName, channelMode);
+ if (channelConf.toLowerCase().equals(PatternCreation.WITHOUT_CONFIDENTIALITY.toLowerCase())) {
+ channelWithSecurity.setIsConfidential(false);
+ } else if (channelConf.toLowerCase().equals(PatternCreation.WITH_CONFIDENTIALITY.toLowerCase())) {
+ channelWithSecurity.setIsConfidential(true);
+ }
+ if (channelAuth.toLowerCase().equals(PatternCreation.WITHOUT_AUTHENTICITY.toLowerCase())) {
+ channelWithSecurity.setAuthenticity(PatternChannelWithSecurity.NO_AUTHENTICITY);
+ } else if (channelAuth.toLowerCase().equals(PatternCreation.WEAK_AUTHENTICITY.toLowerCase())) {
+ channelWithSecurity.setAuthenticity(PatternChannelWithSecurity.WEAK_AUTHENTICITY);
+ } else if (channelAuth.toLowerCase().equals(PatternCreation.STRONG_AUTHENTICITY.toLowerCase())) {
+ channelWithSecurity.setAuthenticity(PatternChannelWithSecurity.STRONG_AUTHENTICITY);
}
+
+ _channelsWithSec.add(channelWithSecurity);
}
return _channelsWithSec;
}
@@ -327,71 +327,65 @@ public class PatternConfig2Json {
return _updatedPatternAttributes;
}
- LinkedHashMap<String, List<String[]>> getChannelsMappingFromJsonFile(JSONArray ja) {
- LinkedHashMap<String, List<String[]>> _channelsMapping = new LinkedHashMap<String, List<String[]>>();
+ List<MappingPatternChannel> getChannelsMappingFromJsonFile(JSONArray ja) {
+ List<MappingPatternChannel> _channelsMapping = new ArrayList<MappingPatternChannel>();
for (int j = 0; j < ja.length(); j++) {
String channelToMap = ja.getJSONObject(j).getString(CHANNEL_TO_MAP);
String taskOfChannelToMap = ja.getJSONObject(j).getString(TASK_OF_CHANNEL_TO_MAP);
- String channelMappedInSameMem = "";
- if (ja.getJSONObject(j).has(CHANNEL_MAPPED_IN_SAME_MEM_AS)) {
- channelMappedInSameMem = ja.getJSONObject(j).getString(CHANNEL_MAPPED_IN_SAME_MEM_AS);
- }
- String taskOfChannelSameMem = "";
- if (ja.getJSONObject(j).has(TASK_OF_CHANNEL_SAME_MEM)) {
- taskOfChannelSameMem = ja.getJSONObject(j).getString(TASK_OF_CHANNEL_SAME_MEM);
- }
- String channelMappedInNewMem = "";
- if (ja.getJSONObject(j).has(CHANNEL_MAPPED_IN_NEW_MEM_CONNECTED_TO_BUS)) {
- channelMappedInNewMem = ja.getJSONObject(j).getString(CHANNEL_MAPPED_IN_NEW_MEM_CONNECTED_TO_BUS);
+ int originChannel = -1;
+ String channelToMapOrigin = ja.getJSONObject(j).getString(CHANNEL_MAPPING_ORIGIN);
+ if (channelToMapOrigin.equals(CHANNEL_MAPPING_ORIGIN_CLONE)) {
+ originChannel = MappingPatternChannel.ORIGIN_CLONE;
+ } else if (channelToMapOrigin.equals(CHANNEL_MAPPING_ORIGIN_PATTERN)) {
+ originChannel = MappingPatternChannel.ORIGIN_PATTERN;
+ } else if (channelToMapOrigin.equals(CHANNEL_MAPPING_ORIGIN_MODEL)) {
+ originChannel = MappingPatternChannel.ORIGIN_MODEL;
}
- if (_channelsMapping.containsKey(taskOfChannelToMap)) {
- if (channelMappedInSameMem != "") {
- String[] channelMap = new String[4];
- channelMap[0] = JDialogPatternHandling.SAME_MEMORY;
- channelMap[1] = channelToMap;
- channelMap[2] = taskOfChannelSameMem;
- channelMap[3] = channelMappedInSameMem;
- _channelsMapping.get(taskOfChannelToMap).add(channelMap);
- } else if (channelMappedInNewMem != "") {
- String[] channelMap = new String[3];
- channelMap[0] = JDialogPatternHandling.NEW_MEMORY;
- channelMap[1] = channelToMap;
- channelMap[2] = channelMappedInNewMem;
- _channelsMapping.get(taskOfChannelToMap).add(channelMap);
+ MappingPatternChannel mappingPatternChannel = new MappingPatternChannel(taskOfChannelToMap, channelToMap, originChannel);
+
+ if (ja.getJSONObject(j).has(CHANNEL_MAPPED_IN_SAME_MEM_AS) && ja.getJSONObject(j).has(TASK_OF_CHANNEL_SAME_MEM)) {
+ int sameMemAsOrigin = -1;
+ String sameChannelMemAsOrigin = ja.getJSONObject(j).getString(CHANNEL_MAPPED_IN_SAME_MEM_AS_ORIGIN);
+ if (sameChannelMemAsOrigin.equals(CHANNEL_MAPPING_ORIGIN_CLONE)) {
+ sameMemAsOrigin = MappingPatternChannel.ORIGIN_CLONE;
+ } else if (sameChannelMemAsOrigin.equals(TASK_MAPPING_ORIGIN_PATTERN)) {
+ sameMemAsOrigin = MappingPatternChannel.ORIGIN_PATTERN;
+ } else if (sameChannelMemAsOrigin.equals(TASK_MAPPING_ORIGIN_MODEL)) {
+ sameMemAsOrigin = MappingPatternChannel.ORIGIN_MODEL;
}
- } else {
- List<String[]> channelMapList = new ArrayList<String[]>();
- if (channelMappedInSameMem != "") {
- String[] channelMap = new String[4];
- channelMap[0] = JDialogPatternHandling.SAME_MEMORY;
- channelMap[1] = channelToMap;
- channelMap[2] = taskOfChannelSameMem;
- channelMap[3] = channelMappedInSameMem;
- channelMapList.add(channelMap);
- } else if (channelMappedInNewMem != "") {
- String[] channelMap = new String[3];
- channelMap[0] = JDialogPatternHandling.NEW_MEMORY;
- channelMap[1] = channelToMap;
- channelMap[2] = channelMappedInNewMem;
- channelMapList.add(channelMap);
- }
- _channelsMapping.put(taskOfChannelToMap, channelMapList);
+ mappingPatternChannel.setTaskAndChannelInSameMem(ja.getJSONObject(j).getString(TASK_OF_CHANNEL_SAME_MEM), ja.getJSONObject(j).getString(CHANNEL_MAPPED_IN_SAME_MEM_AS), sameMemAsOrigin);
+ }else if (ja.getJSONObject(j).has(CHANNEL_MAPPED_IN_NEW_MEM_CONNECTED_TO_BUS)) {
+ mappingPatternChannel.setBusNameForNewMem(ja.getJSONObject(j).getString(CHANNEL_MAPPED_IN_NEW_MEM_CONNECTED_TO_BUS));
}
+ _channelsMapping.add(mappingPatternChannel);
+
}
return _channelsMapping;
}
- JSONArray addTasksMappingInJsonFile(LinkedHashMap<String, Entry<String, String>> _tasksMapping) {
+ JSONArray addTasksMappingInJsonFile(List<MappingPatternTask> _tasksMapping) {
JSONArray ja = new JSONArray();
try {
- for (String task : _tasksMapping.keySet()) {
+ for (MappingPatternTask taskMapping : _tasksMapping) {
JSONObject jo = new JSONObject();
- jo.put(TASK_TO_MAP, task);
- if (_tasksMapping.get(task).getKey().equals(JDialogPatternHandling.SAME_HW)) {
- jo.put(TASK_MAPPED_IN_SAME_HW_AS, _tasksMapping.get(task).getValue());
+ jo.put(TASK_TO_MAP, taskMapping.getTaskToMapName());
+ if (taskMapping.getOrigin() == MappingPatternTask.ORIGIN_CLONE) {
+ jo.put(TASK_MAPPING_ORIGIN, TASK_MAPPING_ORIGIN_CLONE);
+ } else if (taskMapping.getOrigin() == MappingPatternTask.ORIGIN_PATTERN) {
+ jo.put(TASK_MAPPING_ORIGIN, TASK_MAPPING_ORIGIN_PATTERN);
}
- if (_tasksMapping.get(task).getKey().equals(JDialogPatternHandling.NEW_HW)) {
- jo.put(TASK_MAPPED_IN_NEW_HW_CONNECTED_TO_BUS, _tasksMapping.get(task).getValue());
+ if (taskMapping.getSameHwAs() != null) {
+ jo.put(TASK_MAPPED_IN_SAME_HW_AS, taskMapping.getSameHwAs());
+ if (taskMapping.getSameHwAsOrigin() == MappingPatternTask.ORIGIN_CLONE) {
+ jo.put(TASK_MAPPED_IN_SAME_HW_AS_ORIGIN, TASK_MAPPING_ORIGIN_CLONE);
+ } else if (taskMapping.getSameHwAsOrigin() == MappingPatternTask.ORIGIN_PATTERN) {
+ jo.put(TASK_MAPPED_IN_SAME_HW_AS_ORIGIN, TASK_MAPPING_ORIGIN_PATTERN);
+ } else if (taskMapping.getSameHwAsOrigin() == MappingPatternTask.ORIGIN_MODEL) {
+ jo.put(TASK_MAPPED_IN_SAME_HW_AS_ORIGIN, TASK_MAPPING_ORIGIN_MODEL);
+ }
+
+ } else if (taskMapping.getBusNameForNewHw() != null) {
+ jo.put(TASK_MAPPED_IN_NEW_HW_CONNECTED_TO_BUS, taskMapping.getBusNameForNewHw());
}
ja.put(jo);
}
@@ -401,43 +395,53 @@ public class PatternConfig2Json {
return ja;
}
- LinkedHashMap<String, Entry<String, String>> getTasksMappingFromJsonFile(JSONArray ja) {
- LinkedHashMap<String, Entry<String, String>> _tasksMapping = new LinkedHashMap<String, Entry<String, String>>();
+ List<MappingPatternTask> getTasksMappingFromJsonFile(JSONArray ja) {
+ List<MappingPatternTask> _tasksMapping = new ArrayList<MappingPatternTask>();
for (int j = 0; j < ja.length(); j++) {
String taskToMap = ja.getJSONObject(j).getString(TASK_TO_MAP);
- String taskMappedInNewHw = "";
- if (ja.getJSONObject(j).has(TASK_MAPPED_IN_NEW_HW_CONNECTED_TO_BUS)) {
- taskMappedInNewHw = ja.getJSONObject(j).getString(TASK_MAPPED_IN_NEW_HW_CONNECTED_TO_BUS);
+ String taskToMapOrigin = ja.getJSONObject(j).getString(TASK_MAPPING_ORIGIN);
+ int origin = -1;
+ if (taskToMapOrigin.equals(TASK_MAPPING_ORIGIN_CLONE)) {
+ origin = MappingPatternTask.ORIGIN_CLONE;
+ } else if (taskToMapOrigin.equals(TASK_MAPPING_ORIGIN_PATTERN)) {
+ origin = MappingPatternTask.ORIGIN_PATTERN;
}
- String taskMappedInSameHw = "";
- if (ja.getJSONObject(j).has(TASK_MAPPED_IN_SAME_HW_AS)) {
- taskMappedInSameHw = ja.getJSONObject(j).getString(TASK_MAPPED_IN_SAME_HW_AS);
- }
- if (taskMappedInSameHw != "") {
- _tasksMapping.put(taskToMap, new AbstractMap.SimpleEntry<String, String>(JDialogPatternHandling.SAME_HW, taskMappedInSameHw));
- } else if (taskMappedInNewHw != "") {
- _tasksMapping.put(taskToMap, new AbstractMap.SimpleEntry<String, String>(JDialogPatternHandling.NEW_HW, taskMappedInNewHw));
+ MappingPatternTask mappingPatternTask = new MappingPatternTask(taskToMap, origin);
+ if (ja.getJSONObject(j).has(TASK_MAPPED_IN_NEW_HW_CONNECTED_TO_BUS)) {
+ mappingPatternTask.setBusNameForNewHw(ja.getJSONObject(j).getString(TASK_MAPPED_IN_NEW_HW_CONNECTED_TO_BUS));
+ } else if (ja.getJSONObject(j).has(TASK_MAPPED_IN_SAME_HW_AS)) {
+ int sameHwAsOrigin = -1;
+ String sameTaskHwAsOrigin = ja.getJSONObject(j).getString(TASK_MAPPED_IN_SAME_HW_AS_ORIGIN);
+ if (sameTaskHwAsOrigin.equals(TASK_MAPPING_ORIGIN_CLONE)) {
+ sameHwAsOrigin = MappingPatternTask.ORIGIN_CLONE;
+ } else if (sameTaskHwAsOrigin.equals(TASK_MAPPING_ORIGIN_PATTERN)) {
+ sameHwAsOrigin = MappingPatternTask.ORIGIN_PATTERN;
+ } else if (sameTaskHwAsOrigin.equals(TASK_MAPPING_ORIGIN_MODEL)) {
+ sameHwAsOrigin = MappingPatternTask.ORIGIN_MODEL;
+ }
+ mappingPatternTask.setSameHwAs(ja.getJSONObject(j).getString(TASK_MAPPED_IN_SAME_HW_AS), sameHwAsOrigin);
}
+ _tasksMapping.add(mappingPatternTask);
}
return _tasksMapping;
}
- JSONArray addConnectionInJsonFile(LinkedHashMap<String,List<String[]>> _portsConnection) {
+ JSONArray addConnectionInJsonFile(List<PatternConnection> _portsConnection) {
JSONArray ja = new JSONArray();
try {
- for (String taskPattern : _portsConnection.keySet()) {
- for (String[] conn : _portsConnection.get(taskPattern)) {
- JSONObject jo = new JSONObject();
- jo.put(PATTERN_TASK, taskPattern);
- jo.put(PATTERN_PORT, conn[0]);
- jo.put(MODEL_TASK, conn[1]);
- jo.put(MODEL_PORT, conn[2]);
-
- if (conn.length>=4 && conn[3].equals(JDialogPatternHandling.NEW_PORT_OPTION)) {
- jo.put(NEW_PORT, "true");
- }
- ja.put(jo);
+ for (PatternConnection portsConnection : _portsConnection) {
+ JSONObject jo = new JSONObject();
+ jo.put(PATTERN_TASK, portsConnection.getPatternTaskName());
+ jo.put(PATTERN_PORT, portsConnection.getPatternChannel());
+ jo.put(MODEL_TASK, portsConnection.getModelTaskName());
+ jo.put(MODEL_PORT, portsConnection.getModelChannelName());
+
+ if (portsConnection.isNewPort()) {
+ jo.put(NEW_PORT, "true");
+ } else {
+ jo.put(NEW_PORT, "false");
}
+ ja.put(jo);
}
} catch (JSONException e) {
@@ -446,50 +450,17 @@ public class PatternConfig2Json {
return ja;
}
- LinkedHashMap<String, List<String[]>> getConnectionFromJsonFile(JSONArray ja) {
- LinkedHashMap<String, List<String[]>> _portsConnection = new LinkedHashMap<String, List<String[]>>();
+ List<PatternConnection> getConnectionFromJsonFile(JSONArray ja) {
+ List<PatternConnection> _portsConnection = new ArrayList<PatternConnection>();
for (int j = 0; j < ja.length(); j++) {
String patternTask = ja.getJSONObject(j).getString(PATTERN_TASK);
String patternPort = ja.getJSONObject(j).getString(PATTERN_PORT);
String modelTask = ja.getJSONObject(j).getString(MODEL_TASK);
String modelPort = ja.getJSONObject(j).getString(MODEL_PORT);
- String newPort = "";
- if (ja.getJSONObject(j).has(NEW_PORT)) {
- newPort = ja.getJSONObject(j).getString(NEW_PORT);
- }
- if (_portsConnection.containsKey(patternTask)) {
- if (newPort != "") {
- String[] conn = new String[4];
- conn[0] = patternPort;
- conn[1] = modelTask;
- conn[2] = modelPort;
- conn[3] = newPort;
- _portsConnection.get(patternTask).add(conn);
- } else {
- String[] conn = new String[3];
- conn[0] = patternPort;
- conn[1] = modelTask;
- conn[2] = modelPort;
- _portsConnection.get(patternTask).add(conn);
- }
- } else {
- List<String[]> portConnec = new ArrayList<String[]>();
- if (newPort != "") {
- String[] conn = new String[4];
- conn[0] = patternPort;
- conn[1] = modelTask;
- conn[2] = modelPort;
- conn[3] = newPort;
- portConnec.add(conn);
- } else {
- String[] conn = new String[3];
- conn[0] = patternPort;
- conn[1] = modelTask;
- conn[2] = modelPort;
- portConnec.add(conn);
- }
- _portsConnection.put(patternTask, portConnec);
- }
+ String newPort = ja.getJSONObject(j).getString(NEW_PORT);
+ boolean isNewPort = Boolean.parseBoolean(newPort);
+ PatternConnection patternConnection = new PatternConnection(patternTask, patternPort, modelTask, modelPort, isNewPort);
+ _portsConnection.add(patternConnection);
}
return _portsConnection;
}
diff --git a/src/main/java/tmltranslator/patternhandling/PatternConfiguration.java b/src/main/java/tmltranslator/patternhandling/PatternConfiguration.java
index defc67f56c5edbf16cb7c8266bcc0a24e91cc250..1d293e5b88265fa6006b093b9122acf33f03f118 100644
--- a/src/main/java/tmltranslator/patternhandling/PatternConfiguration.java
+++ b/src/main/java/tmltranslator/patternhandling/PatternConfiguration.java
@@ -9,23 +9,21 @@ package tmltranslator.patternhandling;
*/
import java.util.*;
-import java.util.Map.Entry;
import myutil.TraceManager;
-import ui.window.JDialogPatternHandling;
public class PatternConfiguration {
- LinkedHashMap<String, List<String[]>> portsConnection;
- LinkedHashMap<String, String> clonedTasks;
- LinkedHashMap<String, List<Entry<String, String>>> portsConfig;
- LinkedHashMap<String, Entry<String, String>> tasksMapping;
- LinkedHashMap<String, List<String[]>> channelsMapping;
+ List<PatternConnection> portsConnection;
+ List<PatternCloneTask> clonedTasks;
+ List<PatternPortsConfig> portsConfig;
+ List<MappingPatternTask> tasksMapping;
+ List<MappingPatternChannel> channelsMapping;
LinkedHashMap<String, List<AttributeTaskJsonFile>> updatedPatternAttributes;
- LinkedHashMap<String, List<PortTaskJsonFile>> channelsWithSecurity;
+ List<PatternChannelWithSecurity> channelsWithSecurity;
- public PatternConfiguration(LinkedHashMap<String, List<String[]>> portsConnection, LinkedHashMap<String, String> clonedTasks, LinkedHashMap<String, List<Entry<String, String>>> portsConfig, LinkedHashMap<String, Entry<String, String>> tasksMapping, LinkedHashMap<String,List<String[]>> channelsMapping, LinkedHashMap<String, List<AttributeTaskJsonFile>> updatedPatternAttributes, LinkedHashMap<String, List<PortTaskJsonFile>> channelsWithSecurity) {
+ public PatternConfiguration(List<PatternConnection> portsConnection, List<PatternCloneTask> clonedTasks, List<PatternPortsConfig> portsConfig, List<MappingPatternTask> tasksMapping, List<MappingPatternChannel> channelsMapping, LinkedHashMap<String, List<AttributeTaskJsonFile>> updatedPatternAttributes, List<PatternChannelWithSecurity> channelsWithSecurity) {
this.portsConnection = portsConnection;
this.clonedTasks = clonedTasks;
this.portsConfig = portsConfig;
@@ -36,32 +34,32 @@ public class PatternConfiguration {
}
public PatternConfiguration() {
- this.portsConnection = new LinkedHashMap<String, List<String[]>>();
- this.clonedTasks = new LinkedHashMap<String, String>();
- this.portsConfig = new LinkedHashMap<String, List<Entry<String, String>>>();
- this.tasksMapping = new LinkedHashMap<String, Entry<String, String>>();
- this.channelsMapping = new LinkedHashMap<String, List<String[]>>();
+ this.portsConnection = new ArrayList<PatternConnection>();
+ this.clonedTasks = new ArrayList<PatternCloneTask>();
+ this.portsConfig = new ArrayList<PatternPortsConfig>();
+ this.tasksMapping = new ArrayList<MappingPatternTask>();
+ this.channelsMapping = new ArrayList<MappingPatternChannel>();
this.updatedPatternAttributes = new LinkedHashMap<String, List<AttributeTaskJsonFile>>();
- this.channelsWithSecurity = new LinkedHashMap<String, List<PortTaskJsonFile>>();
+ this.channelsWithSecurity = new ArrayList<PatternChannelWithSecurity>();
}
- public LinkedHashMap<String,List<String[]>> getPortsConnection() {
+ public List<PatternConnection> getPortsConnection() {
return portsConnection;
}
- public LinkedHashMap<String, String> getClonedTasks() {
+ public List<PatternCloneTask> getClonedTasks() {
return clonedTasks;
}
- public LinkedHashMap<String, List<Entry<String, String>>> getPortsConfig() {
+ public List<PatternPortsConfig> getPortsConfig() {
return portsConfig;
}
- public LinkedHashMap<String, Entry<String, String>> getTasksMapping() {
+ public List<MappingPatternTask> getTasksMapping() {
return tasksMapping;
}
- public LinkedHashMap<String,List<String[]>> getChannelsMapping() {
+ public List<MappingPatternChannel> getChannelsMapping() {
return channelsMapping;
}
@@ -69,27 +67,27 @@ public class PatternConfiguration {
return updatedPatternAttributes;
}
- public LinkedHashMap<String, List<PortTaskJsonFile>> getChannelsWithSecurity() {
+ public List<PatternChannelWithSecurity> getChannelsWithSecurity() {
return channelsWithSecurity;
}
- public void setPortsConnection(LinkedHashMap<String,List<String[]>> _portsConnection) {
+ public void setPortsConnection(List<PatternConnection> _portsConnection) {
portsConnection = _portsConnection;
}
- public void setClonedTasks(LinkedHashMap<String, String> _clonedTasks) {
+ public void setClonedTasks(List<PatternCloneTask> _clonedTasks) {
clonedTasks = _clonedTasks;
}
- public void setPortsConfig(LinkedHashMap<String, List<Entry<String, String>>> _portsConfig) {
+ public void setPortsConfig(List<PatternPortsConfig> _portsConfig) {
portsConfig = _portsConfig;
}
- public void setTasksMapping(LinkedHashMap<String, Entry<String, String>> _tasksMapping) {
+ public void setTasksMapping(List<MappingPatternTask> _tasksMapping) {
tasksMapping = _tasksMapping;
}
- public void setChannelsMapping(LinkedHashMap<String,List<String[]>> _channelsMapping) {
+ public void setChannelsMapping(List<MappingPatternChannel> _channelsMapping) {
channelsMapping = _channelsMapping;
}
@@ -97,11 +95,31 @@ public class PatternConfiguration {
updatedPatternAttributes = _updatedPatternAttributes;
}
- public void setChannelsWithSecurity(LinkedHashMap<String, List<PortTaskJsonFile>> _channelsWithSecurity) {
+ public void addPortsConnection(PatternConnection _portsConnection) {
+ portsConnection.add(_portsConnection);
+ }
+
+ public void addClonedTasks(PatternCloneTask _clonedTasks) {
+ clonedTasks.add(_clonedTasks);
+ }
+
+ public void addPortsConfig(PatternPortsConfig _portsConfig) {
+ portsConfig.add(_portsConfig);
+ }
+
+ public void addTasksMapping(MappingPatternTask _tasksMapping) {
+ tasksMapping.add(_tasksMapping);
+ }
+
+ public void addChannelsMapping(MappingPatternChannel _channelsMapping) {
+ channelsMapping.add(_channelsMapping);
+ }
+
+ public void setChannelsWithSecurity(List<PatternChannelWithSecurity> _channelsWithSecurity) {
channelsWithSecurity = _channelsWithSecurity;
}
- public void loadConnectedPorts(Vector<String> connectedPortsFull) {
+ /*public void loadConnectedPorts(Vector<String> connectedPortsFull) {
for (String connectedPort : connectedPortsFull) {
String[] splitO = connectedPort.split(JDialogPatternHandling.TASK_CHANNEL_SEPARATOR, 2);
String patternTaskName = splitO[0];
@@ -240,5 +258,5 @@ public class PatternConfiguration {
clonedTasks.put(clonedTaskSplit[0], clonedTaskSplit[1]);
}
}
- }
+ }*/
}
diff --git a/src/main/java/tmltranslator/patternhandling/PatternConnection.java b/src/main/java/tmltranslator/patternhandling/PatternConnection.java
index 143b2b4f322e3c069b46dac3816f46df16d1918f..74112de5de7568c2d8afd46b1f5689d9dae1064c 100644
--- a/src/main/java/tmltranslator/patternhandling/PatternConnection.java
+++ b/src/main/java/tmltranslator/patternhandling/PatternConnection.java
@@ -8,27 +8,41 @@ package tmltranslator.patternhandling;
* @version 1.0 25/10/2023
*/
-import myutil.TraceManager;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
import tmltranslator.*;
public class PatternConnection {
- String patternTaskname;
+ //public static final int NO_AUTHENTICITY = 0;
+ //public static final int WEAK_AUTHENTICITY = 1;
+ //public static final int STRONG_AUTHENTICITY = 2;
+ public final static String PORT_CONNECTION_SEPARATOR = " <-> ";
+ public final static String NEW_PORT_OPTION = " New port";
+ public final static String TASK_CHANNEL_SEPARATOR = "::";
+
+ String patternTaskName;
String patternChannel;
String modelTaskName;
String modelChannelName;
Boolean isNewPort;
+ String newNameOfTaskInModel;
+ String newNameOfChannelInModel;
+ //Boolean isConf;
+ //int auth;
- public PatternConnection(String patternTaskname, String patternChannel, String modelTaskName, String modelChannelName, Boolean isNewPort) {
- this.patternTaskname = patternTaskname;
+ public PatternConnection(String patternTaskName, String patternChannel, String modelTaskName, String modelChannelName, Boolean isNewPort) {
+ this.patternTaskName = patternTaskName;
this.patternChannel = patternChannel;
this.modelTaskName = modelTaskName;
this.modelChannelName = modelChannelName;
this.isNewPort = isNewPort;
}
- public String getPatternTaskname() {
- return patternTaskname;
+ public String getPatternTaskName() {
+ return patternTaskName;
}
public String getPatternChannel() {
@@ -47,8 +61,24 @@ public class PatternConnection {
return isNewPort;
}
- public void setPatternTaskname(String _patternTaskname) {
- patternTaskname = _patternTaskname;
+ public String getNewNameOfTaskInModel() {
+ return newNameOfTaskInModel;
+ }
+
+ public String getNewNameOfChannelInModel() {
+ return newNameOfChannelInModel;
+ }
+
+ /*public Boolean isConfidential() {
+ return isConf;
+ }
+
+ public int getAuthenticity() {
+ return auth;
+ }*/
+
+ public void setPatternTaskName(String _patternTaskName) {
+ patternTaskName = _patternTaskName;
}
public void setPatternChannel(String _patternChannel) {
@@ -66,5 +96,58 @@ public class PatternConnection {
public void setIsNewPort(Boolean _isNewPort) {
isNewPort = _isNewPort;
}
+
+ public void setNewNameOfTaskInModel(String _newNameOfTaskInModel) {
+ newNameOfTaskInModel = _newNameOfTaskInModel;
+ }
+
+ public void setNewNameOfChannelInModel(String _newNameOfChannelInModel) {
+ newNameOfChannelInModel = _newNameOfChannelInModel;
+ }
+
+ /*public void setIsConfidential(Boolean _isConf) {
+ isConf = _isConf;
+ }
+
+ public void setAuthenticity(int _auth) {
+ auth = _auth;
+ }*/
+
+
+ public String getStringDisplay() {
+ if (isNewPort) {
+ return (patternTaskName + TASK_CHANNEL_SEPARATOR + patternChannel + PORT_CONNECTION_SEPARATOR + modelTaskName + TASK_CHANNEL_SEPARATOR+ modelChannelName + NEW_PORT_OPTION);
+ } else {
+ return (patternTaskName + TASK_CHANNEL_SEPARATOR + patternChannel + PORT_CONNECTION_SEPARATOR + modelTaskName + TASK_CHANNEL_SEPARATOR+ modelChannelName);
+ }
+
+ }
+ public boolean isANewChannelRequired(List<PatternConnection> patternConnectionList, LinkedHashMap<String, TaskPattern> patternTasks, List<PatternCloneTask> patternCloneTasks) {
+ if (this.isNewPort()) {
+ return true;
+ } else {
+ List<String> similarTasks = new ArrayList<String>();
+ for (PatternCloneTask patternCloneTask : patternCloneTasks) {
+ if (patternCloneTask.getClonedTask().equals(this.getModelTaskName())) {
+ for (PatternCloneTask patternCloneTask0 : patternCloneTasks) {
+ if (patternCloneTask.getTaskToClone().equals(patternCloneTask0.getTaskToClone())) {
+ similarTasks.add(patternCloneTask0.getClonedTask());
+ }
+ }
+ similarTasks.add(patternCloneTask.getTaskToClone());
+ }
+ }
+ for (PatternConnection patternConnection: patternConnectionList) {
+ if (patternConnection != this && this.getModelChannelName().equals(patternConnection.getModelChannelName()) && !this.getModelTaskName().equals(patternConnection.getModelTaskName()) && !patternConnection.isNewPort() && !similarTasks.contains(patternConnection.getModelTaskName())) {
+ for (PortTaskJsonFile portTaskJsonFile : patternTasks.get(this.getPatternTaskName()).getExternalPorts()) {
+ if (this.getPatternChannel().equals(portTaskJsonFile.getName()) && portTaskJsonFile.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ return true;
+ }
+ }
+ }
+ }
+ }
+ return false;
+ }
}
diff --git a/src/main/java/tmltranslator/patternhandling/PatternIntegration.java b/src/main/java/tmltranslator/patternhandling/PatternIntegration.java
index c62a19369014d58df35f49e3cf92b39d80928954..736fc44d73ffcb07b7c152f5b670a9145e7c0064 100644
--- a/src/main/java/tmltranslator/patternhandling/PatternIntegration.java
+++ b/src/main/java/tmltranslator/patternhandling/PatternIntegration.java
@@ -10,23 +10,12 @@ package tmltranslator.patternhandling;
import myutil.FileUtils;
import myutil.TraceManager;
-import rationals.properties.isNormalized;
import tmltranslator.*;
-import ui.window.JDialogPatternHandling;
-import ui.window.TraceData;
import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Paths;
import java.util.*;
import java.util.Map.Entry;
-import javax.swing.JDialog;
-
-import org.apache.batik.anim.timing.Trace;
-
public class PatternIntegration implements Runnable {
String patternPath;
@@ -36,9 +25,16 @@ public class PatternIntegration implements Runnable {
TMLMapping<?> tmapModel;
TMLMapping<?> tmapPattern;
- HashMap<String, String> renamedChannels = new HashMap<String, String>();
- List<TMLChannel> channelsFromPatternToMap = new ArrayList<TMLChannel>();
- List<TMLChannel> channelsFromClonedToMap = new ArrayList<TMLChannel>();
+ HashMap<String, String> tasksClonedIntoModel = new HashMap<String, String>();
+ HashMap<Entry<String, String>, String> channelsClonedIntoModel = new HashMap<Entry<String, String>, String>();
+
+ HashMap<String, String> tasksOfPatternIntoModel = new HashMap<String, String>();
+ HashMap<Entry<String, String>, String> channelsOfPatternIntoModel = new HashMap<Entry<String, String>, String>();
+
+ HashMap<Entry<String, String>, String> renamedModelChannels = new HashMap<Entry<String, String>, String>();
+ HashMap<TMLTask, List<TMLActivityElement>> clonedTasksToRemElems = new HashMap<TMLTask, List<TMLActivityElement>>();
+ //List<TMLChannel> channelsFromPatternToMap = new ArrayList<TMLChannel>();
+ //List<TMLChannel> channelsFromClonedToMap = new ArrayList<TMLChannel>();
public PatternIntegration(String _patternPath, String _patternName, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks, TMLMapping<?> _tmapModel) {
this.patternPath = _patternPath;
@@ -65,11 +61,12 @@ public class PatternIntegration implements Runnable {
if (tmapModel == null) {
return;
}
+ String appTab = "";
TMLModeling<?> tmlmNew = tmapModel.getTMLModeling();
for (TMLTask task : tmlmNew.getTasks()) {
String[] taskNameSplit = task.getName().split("__");
- TraceManager.addDev("task.getName()==" + task.getName());
task.setName(taskNameSplit[taskNameSplit.length-1]);
+ appTab = taskNameSplit[0];
}
for (TMLChannel ch : tmlmNew.getChannels()) {
String[] channelNameSplit = ch.getName().split("__");
@@ -102,150 +99,231 @@ public class PatternIntegration implements Runnable {
req.setName(requestNameSplit[requestNameSplit.length-1]);
}
- TraceManager.addDev("Model elems init :");
- for (TMLChannel ch : tmlmNew.getChannels()) {
- TraceManager.addDev("ch=" + ch.getName() + ", Origin Task: " + ch.getNameOfOriginTasks() + ", Destination Task: " + ch.getNameOfDestinationTasks() + ", Origin port: " + ch.getOriginPort().getName()+ ", Destination port: " + ch.getDestinationPort().getName());
- }
- for (TMLEvent evt : tmlmNew.getEvents()) {
- TraceManager.addDev("evt=" + evt.getName() + ", Origin Task: " + evt.getOriginTask().getName() + ", Destination Task: " + evt.getDestinationTask().getName() + ", Origin port: " + evt.getOriginPort().getName()+ ", Destination port: " + evt.getDestinationPort().getName());
- }
-
- for (TMLTask task : tmlmNew.getTasks()) {
- TraceManager.addDev("task=" + task.getName());
- for (TMLWriteChannel wr : task.getWriteChannels()) {
- TraceManager.addDev("task wr=" + wr.getName() + ", ch=" + wr.getChannel(0).getName());
- }
- for (TMLReadChannel rd : task.getReadChannels()) {
- TraceManager.addDev("task rd=" + rd.getName() + ", ch=" + rd.getChannel(0).getName());
- }
- for (TMLSendEvent sd : task.getSendEvents()) {
- TraceManager.addDev("task sd=" + sd.getName() + ", evt=" + sd.getEvent().getName());
- }
- for (TMLWaitEvent wt : task.getWaitEvents()) {
- TraceManager.addDev("task wt=" + wt.getName() + ", evt=" + wt.getEvent().getName());
- }
-
- for (TMLChannel wr : task.getWriteTMLChannels()) {
- TraceManager.addDev("task write=" + wr.getName());
- }
- for (TMLChannel rd : task.getReadTMLChannels()) {
- TraceManager.addDev("task read=" + rd.getName());
- }
- for (TMLChannel ch : task.getChannelSet()) {
- TraceManager.addDev("task ch=" + ch.getName());
- }
- for (TMLEvent evt : task.getTMLEvents()) {
- TraceManager.addDev("task evt=" + evt.getName());
- }
+ tmapModel = addClonedTask(tmapModel, patternConfiguration);
+ renamePatternTasksName();
+ renamePatternChannelsName();
+ TraceManager.addDev("%% tasksClonedIntoModel:");
+ for (String tas : tasksClonedIntoModel.keySet()) {
+ TraceManager.addDev("Clone task name in config:" + tas + " Clone task name in Model:" + tasksClonedIntoModel.get(tas));
}
-
-
- TraceManager.addDev("PATTERN elems init :");
- for (TMLChannel ch : tmlmPattern.getChannels()) {
- TraceManager.addDev("ch=" + ch.getName() + ", Origin Task: " + ch.getNameOfOriginTasks() + ", Destination Task: " + ch.getNameOfDestinationTasks() + ", Origin port: " + ch.getOriginPort().getName()+ ", Destination port: " + ch.getDestinationPort().getName());
+ TraceManager.addDev("%% tasksOfPatternIntoModel:");
+ for (String tas : tasksOfPatternIntoModel.keySet()) {
+ TraceManager.addDev("Pattern task name in config:" + tas + " Pattern task name in Model:" + tasksOfPatternIntoModel.get(tas));
}
- for (TMLEvent evt : tmlmPattern.getEvents()) {
- TraceManager.addDev("evt=" + evt.getName() + ", Origin Task: " + evt.getOriginTask().getName() + ", Destination Task: " + evt.getDestinationTask().getName());
+ TraceManager.addDev("%% channelsClonedIntoModel:");
+ for (Entry<String, String> chT : channelsClonedIntoModel.keySet()) {
+ TraceManager.addDev("channel name in config:" + chT.getValue() + " of task: " + chT.getKey() + " Clone channel name in Model:" + channelsClonedIntoModel.get(chT));
}
-
- for (TMLTask task : tmlmPattern.getTasks()) {
- TraceManager.addDev("task=" + task.getName());
- for (TMLWriteChannel wr : task.getWriteChannels()) {
- TraceManager.addDev("task wr=" + wr.getName() + ", ch=" + wr.getChannel(0).getName());
- }
- for (TMLReadChannel rd : task.getReadChannels()) {
- TraceManager.addDev("task rd=" + rd.getName() + ", ch=" + rd.getChannel(0).getName());
- }
- for (TMLSendEvent sd : task.getSendEvents()) {
- TraceManager.addDev("task sd=" + sd.getName() + ", evt=" + sd.getEvent().getName());
- }
- for (TMLWaitEvent wt : task.getWaitEvents()) {
- TraceManager.addDev("task wt=" + wt.getName() + ", evt=" + wt.getEvent().getName());
- }
-
- for (TMLChannel wr : task.getWriteTMLChannels()) {
- TraceManager.addDev("task write=" + wr.getName());
- }
- for (TMLChannel rd : task.getReadTMLChannels()) {
- TraceManager.addDev("task read=" + rd.getName());
- }
- for (TMLChannel ch : task.getChannelSet()) {
- TraceManager.addDev("task ch=" + ch.getName());
- }
- for (TMLEvent evt : task.getTMLEvents()) {
- TraceManager.addDev("task evt=" + evt.getName());
- }
+ TraceManager.addDev("%% channelsOfPatternIntoModel:");
+ for (Entry<String, String> chT : channelsOfPatternIntoModel.keySet()) {
+ TraceManager.addDev("channel Of pattern name in config:" + chT.getValue() + " of task: " + chT.getKey() + " Pattern channel name in Model:" + channelsOfPatternIntoModel.get(chT));
}
-
- tmapModel = addClonedTask(tmapModel, patternConfiguration);
- renamePatternTasksName();
- renamePatternChannelsName();
tmapPattern = updatePatternTasksAttributes(tmapPattern, patternConfiguration.getUpdatedPatternAttributes());
tmapModel = addPatternTasksInModel(tmapModel, tmapPattern, patternTasks);
tmapModel = addPatternInternalChannelsInModel(tmapModel, tmapPattern, patternTasks);
//tmapModel = addNewPortToTasks(tmapModel, patternConfiguration.getPortsConnection(), patternTasks);
- tmapModel = makeConnectionBetweenPatternAndModel(tmapModel, tmapPattern, patternConfiguration.getPortsConnection(), patternTasks);
- tmapModel = configDisconnectedChannels(tmapModel, patternConfiguration.getPortsConfig(), renamedChannels);
+ tmapModel = makeConnectionBetweenPatternAndModel(tmapModel, tmapPattern, patternConfiguration.getPortsConnection(), patternTasks, patternConfiguration.getClonedTasks());
+ tmapModel = configDisconnectedChannels(tmapModel, patternConfiguration.getPortsConfig());
+ tmapModel = removeNotUsedChannelsInClonedTask(tmapModel, clonedTasksToRemElems);
tmapModel = mapTasksInArch(tmapModel, patternConfiguration.getTasksMapping());
- tmapModel = mapTasksInArchAuto(tmapModel, tmapPattern, patternConfiguration.getTasksMapping().keySet(), patternConfiguration, patternTasks);
+ tmapModel = mapTasksInArchAuto(tmapModel, tmapPattern, patternConfiguration.getTasksMapping(), patternConfiguration, patternTasks);
tmapModel = mapChannelsInArch(tmapModel, patternConfiguration.getChannelsMapping());
- tmapModel = mapChannelsInArchAuto(tmapModel, tmapPattern, patternConfiguration.getTasksMapping().keySet(), patternConfiguration.getChannelsMapping().keySet(), patternConfiguration, patternTasks);
+ tmapModel = mapChannelsInArchAuto(tmapModel, tmapPattern, patternConfiguration.getTasksMapping(), patternConfiguration.getChannelsMapping(), patternConfiguration, patternTasks);
+ tmapModel = generateSecurityForChannels(tmapModel, tmapPattern, patternConfiguration, patternTasks, appTab);
+ }
- TraceManager.addDev("Model elems result :");
+ public TMLMapping<?> addClonedTask(TMLMapping<?> _tmapModel, PatternConfiguration _patternConfiguration) {
+ TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
+ for (PatternCloneTask patternCloneTask : _patternConfiguration.getClonedTasks()) {
+ try {
+ String clonedTask = patternCloneTask.getClonedTask();
+ String taskToClone = patternCloneTask.getTaskToClone();
+ TMLModeling<?> _tmlmModelClone = _tmlmModel.deepClone();
+ TMLTask taskClone = _tmlmModelClone.getTMLTaskByName(taskToClone);
+
+ if (taskClone != null) {
+ taskClone.setName(clonedTask);
+ if (_tmlmModel.getTMLTaskByName(taskClone.getName()) != null || tasksClonedIntoModel.containsValue(taskClone.getName()) || tasksOfPatternIntoModel.containsValue(taskClone.getName())) {
+ int indexTask = 0;
+ String taskNameWithIndex = taskClone.getName() + indexTask;
+ while (_tmlmModel.getTMLTaskByName(taskNameWithIndex) != null || tasksClonedIntoModel.containsValue(taskNameWithIndex) || tasksOfPatternIntoModel.containsValue(taskNameWithIndex)) {
+ indexTask += 1;
+ taskNameWithIndex= taskClone.getName() + indexTask;
+ }
+ taskClone.setName(taskNameWithIndex);
+ tasksClonedIntoModel.put(clonedTask, taskNameWithIndex);
+ } else {
+ tasksClonedIntoModel.put(clonedTask, clonedTask);
+ }
+ //List<String> usedChannelsOfClonedTask = new ArrayList<String>();
+ //Map<String, String> oldNewChannelsClonedTaskName = new HashMap<String, String>();
+ //Map<String, String> oldNewEventsClonedTaskName = new HashMap<String, String>();
+ List<TMLActivityElement> aeElemsToRemove = new ArrayList<TMLActivityElement>();
+ for (PatternConnection patternConnection : _patternConfiguration.getPortsConnection()) {
+ if (patternConnection.getModelTaskName().equals(clonedTask) && !patternConnection.isNewPort()) {
+ String modelChannelName = patternConnection.getModelChannelName();
+ if (_tmlmModel.getChannelByName(modelChannelName) != null) {
+ int indexChannel = 0;
+ String channelNameWithIndex = modelChannelName + indexChannel;
+ while (_tmlmModel.getChannelByName(channelNameWithIndex) != null || channelsClonedIntoModel.containsValue(channelNameWithIndex) || channelsOfPatternIntoModel.containsValue(channelNameWithIndex)) {
+ indexChannel += 1;
+ channelNameWithIndex = modelChannelName + indexChannel;
+ }
+ //oldNewChannelsClonedTaskName.put(modelChannelName, channelNameWithIndex);
+ TraceManager.addDev("Channel : old =" + modelChannelName + " New=" + channelNameWithIndex);
+ //patternConnection.setModelChannelName(channelNameWithIndex);
+ channelsClonedIntoModel.put(Map.entry(clonedTask, modelChannelName), channelNameWithIndex);
+ } else if (_tmlmModel.getEventByName(modelChannelName) != null) {
+ int indexEvent = 0;
+ String eventNameWithIndex = modelChannelName + indexEvent;
+ while (_tmlmModel.getEventByName(eventNameWithIndex) != null || channelsClonedIntoModel.containsValue(eventNameWithIndex) || channelsOfPatternIntoModel.containsValue(eventNameWithIndex)) {
+ indexEvent += 1;
+ eventNameWithIndex = modelChannelName + indexEvent;
+ }
+ //oldNewEventsClonedTaskName.put(modelChannelName, eventNameWithIndex);
+ //patternConnection.setModelChannelName(eventNameWithIndex);
+ channelsClonedIntoModel.put(Map.entry(clonedTask, modelChannelName), eventNameWithIndex);
+ } else if (channelsClonedIntoModel.containsValue(modelChannelName) || channelsOfPatternIntoModel.containsValue(modelChannelName)){
+ int index = 0;
+ String nameWithIndex = modelChannelName + index;
+ while (channelsClonedIntoModel.containsValue(nameWithIndex) || channelsOfPatternIntoModel.containsValue(nameWithIndex)) {
+ index += 1;
+ nameWithIndex = modelChannelName + index;
+ }
+ channelsClonedIntoModel.put(Map.entry(clonedTask, modelChannelName), nameWithIndex);
+ } else {
+ channelsClonedIntoModel.put(Map.entry(clonedTask, modelChannelName), modelChannelName);
+ }
+ } else if (patternConnection.getModelTaskName().equals(clonedTask) && patternConnection.isNewPort()) {
+
+ }
+ }
+ /*for (MappingPatternChannel mappingPatternChannel : _patternConfiguration.getChannelsMapping()) {
+ //for (String[] st : _patternConfiguration.getChannelsMapping().get(taskOfChannelToMap)) {
+ if (mappingPatternChannel.getTaskOfChannelToMap().equals(clonedTask)) {
+ if (oldNewChannelsClonedTaskName.keySet().contains(st[1])) {
+ st[1] = oldNewChannelsClonedTaskName.get(st[1]);
+ } else if (oldNewEventsClonedTaskName.keySet().contains(st[1])) {
+ st[1] = oldNewEventsClonedTaskName.get(st[1]);
+ }
+ }
+ if (st.length == 4) {
+ if (st[2].equals(clonedTask)) {
+ if (oldNewChannelsClonedTaskName.keySet().contains(st[3])) {
+ st[3] = oldNewChannelsClonedTaskName.get(st[3]);
+ } else if (oldNewEventsClonedTaskName.keySet().contains(st[3])) {
+ st[3] = oldNewEventsClonedTaskName.get(st[3]);
+ }
+ }
+ }
+ //}
+ }*/
+ for (TMLActivityElement ae : taskClone.getActivityDiagram().getElements()) {
+ if (ae instanceof TMLActivityElementChannel) {
+ TMLActivityElementChannel aeChannel = (TMLActivityElementChannel) ae;
+ for (int i=0; i < aeChannel.getNbOfChannels(); i++) {
+ if (channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeChannel.getChannel(i).getName())) == null) {
+ //TMLActivityElement prevElem = taskClone.getActivityDiagram().getPrevious(ae);
+ //prevElem.setNewNext(ae, ae.getNextElement(0));
+ aeElemsToRemove.add(ae);
+ } else {
+
+ for (TMLPort port : aeChannel.getChannel(i).getOriginPorts()) {
+ port.setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeChannel.getChannel(i).getName())));
+ }
+ for (TMLPort port : aeChannel.getChannel(i).getDestinationPorts()) {
+ port.setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeChannel.getChannel(i).getName())));
+ }
+ if (aeChannel.getChannel(i).getOriginPort() != null) {
+ aeChannel.getChannel(i).getOriginPort().setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeChannel.getChannel(i).getName())));
+ TraceManager.addDev("Port Origin New Name = " + aeChannel.getChannel(i).getOriginPort().getName());
+ }
+ if (aeChannel.getChannel(i).getDestinationPort() != null) {
+ aeChannel.getChannel(i).getDestinationPort().setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeChannel.getChannel(i).getName())));
+ }
+ TraceManager.addDev("Name Channel Clone Before =" + aeChannel.getChannel(i).getName());
+ aeChannel.getChannel(i).setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeChannel.getChannel(i).getName())));
+ TraceManager.addDev("Name Channel Clone After =" + aeChannel.getChannel(i).getName());
+ if (_tmlmModel.getChannelByName(aeChannel.getChannel(i).getName()) == null) {
+ _tmlmModel.addChannel(aeChannel.getChannel(i));
+ //channelsFromClonedToMap.add(aeChannel.getChannel(i));
+ }
+ }
+ }
+ } else if (ae instanceof TMLActivityElementEvent) {
+ TMLActivityElementEvent aeEvent = (TMLActivityElementEvent) ae;
+ //if (!oldNewEventsClonedTaskName.keySet().contains(aeEvent.getEvent().getName())) {
+ if (channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeEvent.getEvent().getName())) == null) {
+ //TMLActivityElement prevElem = taskClone.getActivityDiagram().getPrevious(ae);
+ //prevElem.setNewNext(ae, ae.getNextElement(0));
+ aeElemsToRemove.add(ae);
+ } else {
+
+ for (TMLPort port : aeEvent.getEvent().getOriginPorts()) {
+ port.setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeEvent.getEvent().getName())));
+ }
+ for (TMLPort port : aeEvent.getEvent().getDestinationPorts()) {
+ port.setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeEvent.getEvent().getName())));
+ }
+ if (aeEvent.getEvent().getOriginPort() != null) {
+ aeEvent.getEvent().getOriginPort().setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeEvent.getEvent().getName())));
+ }
+ if (aeEvent.getEvent().getDestinationPort() != null) {
+ aeEvent.getEvent().getDestinationPort().setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeEvent.getEvent().getName())));
+ }
+ aeEvent.getEvent().setName(channelsClonedIntoModel.get(Map.entry(taskClone.getName(), aeEvent.getEvent().getName())));
+ if (_tmlmModel.getEventByName(aeEvent.getEvent().getName()) == null) {
+ _tmlmModel.addEvent(aeEvent.getEvent());
+ }
+ }
+ }
+ }
+ /*for (TMLActivityElement ae : aeElemsToRemove) {
+ taskClone.getActivityDiagram().removeElement(ae);
+ }*/
+ clonedTasksToRemElems.put(taskClone, aeElemsToRemove);
+ _tmlmModel.addTask(taskClone);
+ }
+ } catch (TMLCheckingError err) {
- for (TMLChannel ch : tmlmNew.getChannels()) {
- TraceManager.addDev("ch=" + ch.getName() + ", Origin Task: " + ch.getNameOfOriginTasks() + ", Destination Task: " + ch.getNameOfDestinationTasks() + ", Origin port: " + ch.getOriginPort().getName()+ ", Destination port: " + ch.getDestinationPort().getName());
- }
- for (TMLEvent evt : tmlmNew.getEvents()) {
- TraceManager.addDev("evt=" + evt.getName() + ", Origin Task: " + evt.getOriginTask().getName() + ", Destination Task: " + evt.getDestinationTask().getName());
- }
- for (TMLTask task : tmlmNew.getTasks()) {
- TraceManager.addDev("task=" + task.getName());
- for (TMLWriteChannel wr : task.getWriteChannels()) {
- TraceManager.addDev("task wr=" + wr.getName() + ", ch=" + wr.getChannel(0).getName());
- }
- for (TMLReadChannel rd : task.getReadChannels()) {
- TraceManager.addDev("task rd=" + rd.getName() + ", ch=" + rd.getChannel(0).getName());
- }
- for (TMLSendEvent sd : task.getSendEvents()) {
- TraceManager.addDev("task sd=" + sd.getName() + ", evt=" + sd.getEvent().getName());
- }
- for (TMLWaitEvent wt : task.getWaitEvents()) {
- TraceManager.addDev("task wt=" + wt.getName() + ", evt=" + wt.getEvent().getName());
}
+ }
+ return _tmapModel;
+ }
- for (TMLChannel wr : task.getWriteTMLChannels()) {
- TraceManager.addDev("task write=" + wr.getName());
+ public TMLMapping<?> removeNotUsedChannelsInClonedTask(TMLMapping<?> _tmapModel, HashMap<TMLTask, List<TMLActivityElement>> _clonedTaskToRemoveElems) {
+ for (TMLTask taskClone : _clonedTaskToRemoveElems.keySet()) {
+ TraceManager.addDev("removeNotUsed: taskClone=" + taskClone.getName());
+ List<TMLActivityElement> _aeElemsToRemove = _clonedTaskToRemoveElems.get(taskClone);
+ for (TMLActivityElement ae : _aeElemsToRemove) {
+ TMLActivityElement prevElem = taskClone.getActivityDiagram().getPrevious(ae);
+ prevElem.setNewNext(ae, ae.getNextElement(0));
}
- for (TMLChannel rd : task.getReadTMLChannels()) {
- TraceManager.addDev("task read=" + rd.getName());
- }
- for (TMLChannel ch : task.getChannelSet()) {
- TraceManager.addDev("task ch=" + ch.getName());
- }
- for (TMLEvent evt : task.getTMLEvents()) {
- TraceManager.addDev("task evt=" + evt.getName());
+ for (TMLActivityElement ae : _aeElemsToRemove) {
+ taskClone.getActivityDiagram().removeElement(ae);
}
}
- }
+ return _tmapModel;
+ }
public void renamePatternTasksName() {
TMLModeling<?> tmlmModel = tmapModel.getTMLModeling();
- TMLModeling<?> tmlmPattern = tmapPattern.getTMLModeling();
+ //TMLModeling<?> tmlmPattern = tmapPattern.getTMLModeling();
String[] patternTasksKeys = patternTasks.keySet().toArray(new String[patternTasks.keySet().size()]);
- List<String> newTasksNames = new ArrayList<String>();
- for (int i = 0; i < patternTasks.keySet().size(); i++) {
- String taskName = patternTasksKeys[i];
- if (tmlmModel.getTMLTaskByName(taskName) != null || newTasksNames.contains(taskName)) {
+ //List<String> newTasksNames = new ArrayList<String>();
+ //for (int i = 0; i < patternTasks.keySet().size(); i++) {
+ for (String taskName : patternTasksKeys) {
+ //String taskName = patternTasksKeys[i];
+ if (tmlmModel.getTMLTaskByName(taskName) != null || tasksOfPatternIntoModel.containsValue(taskName) || tasksClonedIntoModel.containsValue(taskName)) {
int indexTask = 0;
String taskNameWithIndex = taskName + indexTask;
- while (tmlmModel.getTMLTaskByName(taskNameWithIndex) != null || newTasksNames.contains(taskNameWithIndex)) {
+ while (tmlmModel.getTMLTaskByName(taskNameWithIndex) != null || tasksOfPatternIntoModel.containsValue(taskNameWithIndex) || tasksClonedIntoModel.containsValue(taskNameWithIndex)) {
indexTask += 1;
taskNameWithIndex= taskName + indexTask;
}
- TMLTask taskPattern = tmlmPattern.getTMLTaskByName(taskName);
+ tasksOfPatternIntoModel.put(taskName, taskNameWithIndex);
+ /*TMLTask taskPattern = tmlmPattern.getTMLTaskByName(taskName);
taskPattern.setName(taskNameWithIndex);
- newTasksNames.add(taskNameWithIndex);
if (patternConfiguration.getPortsConnection().containsKey(taskName)) {
patternConfiguration.getPortsConnection().put(taskNameWithIndex, patternConfiguration.getPortsConnection().remove(taskName));
}
@@ -263,7 +341,10 @@ public class PatternIntegration implements Runnable {
}
if (patternTasks.containsKey(taskName)) {
patternTasks.put(taskNameWithIndex, patternTasks.remove(taskName));
- }
+ }*/
+
+ } else {
+ tasksOfPatternIntoModel.put(taskName, taskName);
}
}
}
@@ -271,175 +352,21 @@ public class PatternIntegration implements Runnable {
public void renamePatternChannelsName() {
TMLModeling<?> tmlmModel = tmapModel.getTMLModeling();
TMLModeling<?> tmlmPattern = tmapPattern.getTMLModeling();
- Map<String, String> oldNewChannelName = new HashMap<String,String>();
- Map<String, String> oldNewEventName = new HashMap<String,String>();
+ //Map<String, String> oldNewChannelName = new HashMap<String,String>();
+ //Map<String, String> oldNewEventName = new HashMap<String,String>();
for (String taskName : patternTasks.keySet()) {
TaskPattern tp = patternTasks.get(taskName);
- for (int i = 0 ; i < tp.getExternalPorts().size() ; i++) {
- PortTaskJsonFile extPort = tp.getExternalPorts().get(i);
- if (tmlmModel.getChannelByName(extPort.name) != null || oldNewChannelName.values().contains(extPort.name)) {
- if (oldNewChannelName.containsKey(extPort.name)) {
- TMLChannel channelPattern = tmlmPattern.getChannelByName(extPort.name);
- channelPattern.setName(oldNewChannelName.get(extPort.name));
- if (patternConfiguration.getPortsConnection().containsKey(taskName)) {
- for (String[] pc : patternConfiguration.getPortsConnection().get(taskName)) {
- if (pc[0].equals(extPort.name)) {
- pc[0] = oldNewChannelName.get(extPort.name);
- }
- }
- }
-
- if (patternConfiguration.getChannelsMapping().containsKey(taskName)) {
- for (String[] cm : patternConfiguration.getChannelsMapping().get(taskName)) {
- if (cm[0].equals(extPort.name)) {
- cm[0] = oldNewChannelName.get(extPort.name);
- }
- }
- }
- if (patternConfiguration.getChannelsWithSecurity().containsKey(taskName)) {
- for (PortTaskJsonFile portTask : patternConfiguration.getChannelsWithSecurity().get(taskName)) {
- if (portTask.getName().equals(extPort.name)) {
- portTask.name = oldNewChannelName.get(extPort.name);
- }
- }
- }
- extPort.name = oldNewChannelName.get(extPort.name);
- TraceManager.addDev("renamePatternChannelsName-0 : extPort.name= " + extPort.name);
- } else {
- boolean toRename = true;
- if (patternConfiguration.getPortsConnection().containsKey(taskName)) {
- for (String[] portConnection : patternConfiguration.getPortsConnection().get(taskName)) {
-
- TraceManager.addDev("renamePatternChannelsName-1 : extPort.name= " + extPort.name);
- TraceManager.addDev("renamePatternChannelsName-1 : portConnection[0]= " + portConnection[0]);
- TraceManager.addDev("renamePatternChannelsName-1 : portConnection[1]= " + portConnection[1]);
- TraceManager.addDev("renamePatternChannelsName-1 : portConnection[2]= " + portConnection[2]);
- if (portConnection[0].equals(extPort.getName()) && portConnection[2].equals(extPort.getName()) && portConnection.length == 3) {
- if (tmlmModel.getChannelByName(extPort.name).getOriginTask().getName().equals(portConnection[1]) && extPort.mode.equals(PatternCreation.MODE_INPUT)) {
- toRename = false;
- break;
- }
- if (tmlmModel.getChannelByName(extPort.name).getDestinationTask().getName().equals(portConnection[1]) && extPort.mode.equals(PatternCreation.MODE_OUTPUT)) {
- toRename = false;
- break;
- }
- }
- }
- }
- if (toRename) {
- int indexChannel = 0;
- String channelNameWithIndex = extPort.name + indexChannel;
- while (tmlmModel.getChannelByName(channelNameWithIndex) != null || oldNewChannelName.values().contains(extPort.name)) {
- indexChannel += 1;
- channelNameWithIndex= extPort.name + indexChannel;
- }
- TMLChannel channelPattern = tmlmPattern.getChannelByName(extPort.name);
- oldNewChannelName.put(extPort.name, channelNameWithIndex);
- channelPattern.setName(channelNameWithIndex);
- if (patternConfiguration.getPortsConnection().containsKey(taskName)) {
- for (String[] pc : patternConfiguration.getPortsConnection().get(taskName)) {
- if (pc[0].equals(extPort.name)) {
- pc[0] = channelNameWithIndex;
- }
- }
- }
-
- if (patternConfiguration.getChannelsMapping().containsKey(taskName)) {
- for (String[] cm : patternConfiguration.getChannelsMapping().get(taskName)) {
- if (cm[0].equals(extPort.name)) {
- cm[0] = channelNameWithIndex;
- }
- }
- }
- if (patternConfiguration.getChannelsWithSecurity().containsKey(taskName)) {
- for (PortTaskJsonFile portTask : patternConfiguration.getChannelsWithSecurity().get(taskName)) {
- if (portTask.getName().equals(extPort.name)) {
- portTask.name = channelNameWithIndex;
- }
- }
- }
- extPort.name = channelNameWithIndex;
- TraceManager.addDev("renamePatternChannelsName-2 : extPort.name= " + extPort.name);
- }
- }
- } else if (tmlmModel.getEventByName(extPort.name) != null || oldNewEventName.values().contains(extPort.name)) {
- if (oldNewEventName.containsKey(extPort.name)) {
- if (patternConfiguration.getPortsConnection().containsKey(taskName)) {
- for (String[] pc : patternConfiguration.getPortsConnection().get(taskName)) {
- if (pc[0].equals(extPort.name)) {
- pc[0] = oldNewEventName.get(extPort.name);
- }
- }
- }
- extPort.name = oldNewEventName.get(extPort.name);
- } else {
- boolean toRename = true;
- if (patternConfiguration.getPortsConnection().containsKey(taskName)) {
- for (String[] portConnection : patternConfiguration.getPortsConnection().get(taskName)) {
- if (portConnection[0].equals(extPort.getName()) && portConnection[2].equals(extPort.getName()) && portConnection.length == 3) {
- if (tmlmModel.getEventByName(extPort.name).getOriginTask().getName().equals(portConnection[1]) && extPort.mode.equals(PatternCreation.MODE_INPUT)) {
- toRename = false;
- break;
- }
- if (tmlmModel.getEventByName(extPort.name).getDestinationTask().getName().equals(portConnection[1]) && extPort.mode.equals(PatternCreation.MODE_OUTPUT)) {
- toRename = false;
- break;
- }
- }
- }
- }
- if (toRename) {
- int indexEvent = 0;
- String eventNameWithIndex = extPort.name + indexEvent;
- while (tmlmModel.getEventByName(eventNameWithIndex) != null || oldNewEventName.values().contains(extPort.name)) {
- indexEvent += 1;
- eventNameWithIndex= extPort.name + indexEvent;
- }
- TMLEvent eventPattern = tmlmPattern.getEventByName(extPort.name);
- eventPattern.setName(eventNameWithIndex);
- oldNewEventName.put(extPort.name, eventNameWithIndex);
- if (patternConfiguration.getPortsConnection().containsKey(taskName)) {
- for (String[] pc : patternConfiguration.getPortsConnection().get(taskName)) {
- if (pc[0].equals(extPort.name)) {
- pc[0] = eventNameWithIndex;
- }
- }
- }
- extPort.name = eventNameWithIndex;
- }
- }
- }
- }
-
for (int i = 0 ; i < tp.getInternalPorts().size() ; i++) {
PortTaskJsonFile extPort = tp.getInternalPorts().get(i);
- if (tmlmModel.getChannelByName(extPort.name) != null) {
- TraceManager.addDev("tmlmModel.getChannelByName(extPort.name) != null :" + extPort.name);
- if (oldNewChannelName.containsKey(extPort.name)) {
- if (patternConfiguration.getChannelsMapping().containsKey(taskName)) {
- for (String[] cm : patternConfiguration.getChannelsMapping().get(taskName)) {
- if (cm[0].equals(extPort.name)) {
- cm[0] = oldNewChannelName.get(extPort.name);
- }
- }
- }
- if (patternConfiguration.getChannelsWithSecurity().containsKey(taskName)) {
- for (PortTaskJsonFile portTask : patternConfiguration.getChannelsWithSecurity().get(taskName)) {
- if (portTask.getName().equals(extPort.name)) {
- portTask.name = oldNewChannelName.get(extPort.name);
- }
- }
- }
- extPort.name = oldNewChannelName.get(extPort.name);
- TraceManager.addDev("oldNewChannelName.containsKey(extPort.name) :" + extPort.name);
- } else {
+ if (extPort.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ if (tmlmModel.getChannelByName(extPort.getName()) != null) {
int indexChannel = 0;
- String channelNameWithIndex = extPort.name + indexChannel;
- while (tmlmModel.getChannelByName(channelNameWithIndex) != null) {
+ String channelNameWithIndex = extPort.getName() + indexChannel;
+ while (tmlmModel.getChannelByName(channelNameWithIndex) != null || channelsOfPatternIntoModel.containsValue(channelNameWithIndex) || channelsClonedIntoModel.containsValue(channelNameWithIndex)) {
indexChannel += 1;
- channelNameWithIndex= extPort.name + indexChannel;
+ channelNameWithIndex= extPort.getName() + indexChannel;
}
- TMLChannel channelPattern = tmlmPattern.getChannelByName(extPort.name);
+ /*TMLChannel channelPattern = tmlmPattern.getChannelByName(extPort.name);
oldNewChannelName.put(extPort.name, channelNameWithIndex);
channelPattern.setName(channelNameWithIndex);
if (patternConfiguration.getChannelsMapping().containsKey(taskName)) {
@@ -456,107 +383,77 @@ public class PatternIntegration implements Runnable {
}
}
}
- extPort.name = channelNameWithIndex;
- TraceManager.addDev("oldNewChannelName.containsKey(extPort.name) else :" + extPort.name);
- }
-
- } else if (tmlmModel.getEventByName(extPort.name) != null) {
- if (oldNewEventName.containsKey(extPort.name)) {
- extPort.name = oldNewEventName.get(extPort.name);
- TraceManager.addDev("else if oldNewEventName.containsKey(extPort.name) :" + extPort.name);
- } else {
+ extPort.name = channelNameWithIndex;*/
+ channelsOfPatternIntoModel.put(Map.entry(taskName, extPort.getName()), channelNameWithIndex);
+ TraceManager.addDev("oldNewChannelName.containsKey(extPort.name) else :" + extPort.getName());
+
+ } else if (tmlmModel.getEventByName(extPort.getName()) != null) {
int indexEvent = 0;
String eventNameWithIndex = extPort.name + indexEvent;
- while (tmlmModel.getEventByName(eventNameWithIndex) != null) {
+ while (tmlmModel.getEventByName(eventNameWithIndex) != null || channelsOfPatternIntoModel.containsValue(eventNameWithIndex) || channelsClonedIntoModel.containsValue(eventNameWithIndex)) {
indexEvent += 1;
- eventNameWithIndex= extPort.name + indexEvent;
+ eventNameWithIndex= extPort.getName() + indexEvent;
}
- TMLEvent eventPattern = tmlmPattern.getEventByName(extPort.name);
+ /*TMLEvent eventPattern = tmlmPattern.getEventByName(extPort.name);
oldNewEventName.put(extPort.name, eventNameWithIndex);
eventPattern.setName(eventNameWithIndex);
- extPort.name = eventNameWithIndex;
+ extPort.name = eventNameWithIndex;*/
+ channelsOfPatternIntoModel.put(Map.entry(taskName, extPort.getName()), eventNameWithIndex);
TraceManager.addDev("else if oldNewEventName.containsKey(extPort.name) else :" + extPort.name);
+ } else if (channelsOfPatternIntoModel.containsValue(extPort.getName()) || channelsClonedIntoModel.containsValue(extPort.getName())) {
+ int index = 0;
+ String nameWithIndex = extPort.getName() + index;
+ while (channelsOfPatternIntoModel.containsValue(nameWithIndex) || channelsClonedIntoModel.containsValue(nameWithIndex)) {
+ index += 1;
+ nameWithIndex= extPort.getName() + index;
+ }
+ channelsOfPatternIntoModel.put(Map.entry(taskName, extPort.getName()), nameWithIndex);
+ } else {
+ channelsOfPatternIntoModel.put(Map.entry(taskName, extPort.getName()), extPort.getName());
}
}
}
}
- }
-
- public TMLMapping<?> addPatternTasksInModel(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, LinkedHashMap<String, TaskPattern> _patternTasks) {
- TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
- TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
- for (String taskName : _patternTasks.keySet()) {
-
- TMLTask taskPattern = _tmlmPattern.getTMLTaskByName(taskName);
- if (taskPattern != null) {
- /*int indexTask = 0;
- String taskNameWithIndex = taskName + indexTask;
- while (_tmlmModel.getTMLTaskByName(taskNameWithIndex) != null) {
- indexTask += 1;
- taskNameWithIndex= taskName + indexTask;
- }
- taskPattern.setName(taskNameWithIndex);*/
- if (_tmlmModel.getTMLTaskByName(taskName) == null) {
- _tmlmModel.addTask(taskPattern);
- TraceManager.addDev("addPatternTasksInModel: taskName="+taskName);
- }
- }
- }
- return _tmapModel;
- }
-
- public TMLMapping<?> addPatternInternalChannelsInModel(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, LinkedHashMap<String, TaskPattern> _patternTasks) {
- TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
- TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
- for (String taskName : _patternTasks.keySet()) {
- for (PortTaskJsonFile portTask : _patternTasks.get(taskName).internalPorts) {
- TMLChannel channelPattern = _tmlmPattern.getChannelByName(portTask.name);
- TMLEvent eventPattern = _tmlmPattern.getEventByName(portTask.name);
- if (channelPattern != null) {
- /*if (_tmlmModel.getChannelByName(portTask.name) != null) {
- int indexChannel = 0;
- String channelNameWithIndex = portTask.name + indexChannel;
- while (_tmlmModel.getChannelByName(channelNameWithIndex) != null) {
- indexChannel += 1;
- channelNameWithIndex = portTask.name + indexChannel;
- }
- }*/
- if (_tmlmModel.getChannelByName(portTask.name) == null) {
- _tmlmModel.addChannel(channelPattern);
- channelsFromPatternToMap.add(channelPattern);
- TraceManager.addDev("addPatternInternalChannelsInModel: channelName="+portTask.name);
+ for (PatternConnection patternConnection : patternConfiguration.getPortsConnection()) {
+ if (patternConnection.isANewChannelRequired(patternConfiguration.getPortsConnection(), patternTasks, patternConfiguration.getClonedTasks())) {
+ if (tmlmModel.getChannelByName(patternConnection.getPatternChannel()) != null) {
+ int indexChannel = 0;
+ String channelNameWithIndex = patternConnection.getPatternChannel() + indexChannel;
+ while (tmlmModel.getChannelByName(channelNameWithIndex) != null || channelsOfPatternIntoModel.containsValue(channelNameWithIndex) || channelsClonedIntoModel.containsValue(channelNameWithIndex)) {
+ indexChannel += 1;
+ channelNameWithIndex= patternConnection.getPatternChannel() + indexChannel;
+ }
+ channelsOfPatternIntoModel.put(Map.entry(patternConnection.getPatternTaskName(), patternConnection.getPatternChannel()), channelNameWithIndex);
+
+ } else if (tmlmModel.getEventByName(patternConnection.getPatternChannel()) != null) {
+ int indexEvent = 0;
+ String eventNameWithIndex = patternConnection.getPatternChannel() + indexEvent;
+ while (tmlmModel.getEventByName(eventNameWithIndex) != null || channelsOfPatternIntoModel.containsValue(eventNameWithIndex) || channelsClonedIntoModel.containsValue(eventNameWithIndex)) {
+ indexEvent += 1;
+ eventNameWithIndex= patternConnection.getPatternChannel() + indexEvent;
}
- } else if (eventPattern != null) {
- if (_tmlmModel.getEventByName(portTask.name) == null) {
- _tmlmModel.addEvent(eventPattern);
- TraceManager.addDev("addPatternInternalChannelsInModel: eventName="+portTask.name);
+ channelsOfPatternIntoModel.put(Map.entry(patternConnection.getPatternTaskName(), patternConnection.getPatternChannel()), eventNameWithIndex);
+ } else if (channelsOfPatternIntoModel.containsValue(patternConnection.getPatternChannel()) || channelsClonedIntoModel.containsValue(patternConnection.getPatternChannel())) {
+ int index = 0;
+ String nameWithIndex = patternConnection.getPatternChannel() + index;
+ while (channelsOfPatternIntoModel.containsValue(nameWithIndex) || channelsClonedIntoModel.containsValue(nameWithIndex)) {
+ index += 1;
+ nameWithIndex= patternConnection.getPatternChannel() + index;
}
+ channelsOfPatternIntoModel.put(Map.entry(patternConnection.getPatternTaskName(), patternConnection.getPatternChannel()), nameWithIndex);
+ } else {
+ channelsOfPatternIntoModel.put(Map.entry(patternConnection.getPatternTaskName(), patternConnection.getPatternChannel()), patternConnection.getPatternChannel());
}
}
}
- return _tmapModel;
}
- /*public TMLMapping<?> updatePatternTasksAttributes(TMLMapping<?> _tmapPattern, LinkedHashMap<String, TaskPattern> _patternTasks) {
- TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
- for (String taskName : _patternTasks.keySet()) {
- TMLTask taskPattern = _tmlmPattern.getTMLTaskByName(taskName);
- if (taskPattern != null) {
- for (int i=0; i < _patternTasks.get(taskName).getAttributes().size(); i++) {
- TMLAttribute attribTaskPattern = taskPattern.getAttributeByName(_patternTasks.get(taskName).getAttributes().get(i).getName());
- attribTaskPattern.initialValue = _patternTasks.get(taskName).getAttributes().get(i).getValue();
- }
- }
- }
- return _tmapPattern;
- }*/
-
public TMLMapping<?> updatePatternTasksAttributes(TMLMapping<?> _tmapPattern, LinkedHashMap<String, List<AttributeTaskJsonFile>> _updatedPatternAttributes) {
TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
for (String taskName : _updatedPatternAttributes.keySet()) {
TMLTask taskPattern = _tmlmPattern.getTMLTaskByName(taskName);
if (taskPattern != null) {
- for (int i=0; i < _updatedPatternAttributes.get(taskName).size(); i++) {
+ for (int i = 0; i < _updatedPatternAttributes.get(taskName).size(); i++) {
TMLAttribute attribTaskPattern = taskPattern.getAttributeByName(_updatedPatternAttributes.get(taskName).get(i).getName());
attribTaskPattern.initialValue = _updatedPatternAttributes.get(taskName).get(i).getValue();
}
@@ -565,183 +462,134 @@ public class PatternIntegration implements Runnable {
return _tmapPattern;
}
+ public TMLMapping<?> addPatternTasksInModel(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, LinkedHashMap<String, TaskPattern> _patternTasks) {
+ TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
+ TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
+ try {
+ TMLModeling<?> _tmlmPatternClone = _tmlmPattern.deepClone();
+ for (String taskName : _patternTasks.keySet()) {
+ TMLTask taskPattern = _tmlmPatternClone.getTMLTaskByName(taskName);
+ if (taskPattern != null) {
+ if (_tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(taskName)) == null) {
+ taskPattern.setName(tasksOfPatternIntoModel.get(taskName));
+ _tmlmModel.addTask(taskPattern);
+ TraceManager.addDev("addPatternTasksInModel: taskName=" + tasksOfPatternIntoModel.get(taskName));
+ }
+ }
+ }
+ } catch (TMLCheckingError err) {
- public TMLMapping<?> addClonedTask(TMLMapping<?> _tmapModel, PatternConfiguration _patternConfiguration) {
+ }
+ return _tmapModel;
+ }
+
+ public TMLMapping<?> addPatternInternalChannelsInModel(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, LinkedHashMap<String, TaskPattern> _patternTasks) {
TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
- for (String clonedTask : _patternConfiguration.getClonedTasks().keySet()) {
- try {
- TMLModeling<?> _tmlmModelClone = _tmlmModel.deepClone();
- TMLTask taskClone = _tmlmModelClone.getTMLTaskByName(_patternConfiguration.getClonedTasks().get(clonedTask));
-
- if (taskClone != null) {
- taskClone.setName(clonedTask);
- /*if (_tmlmModel.getTMLTaskByName(taskClone.getName()) != null) {
- int indexTask = 0;
- String taskNameWithIndex = taskClone.getName() + indexTask;
- while (_tmlmModel.getTMLTaskByName(taskNameWithIndex) != null) {
- indexTask += 1;
- taskNameWithIndex= taskClone.getName() + indexTask;
- }
- taskClone.setName(taskNameWithIndex);
- _patternConfiguration.getClonedTasks().put(taskNameWithIndex, _patternConfiguration.getClonedTasks().remove(clonedTask));
- _patternConfiguration.getTasksMapping().put(taskNameWithIndex, _patternConfiguration.getTasksMapping().remove(clonedTask));
- for (String taskPattern : _patternConfiguration.getPortsConnection().keySet()) {
- for (String[] st : _patternConfiguration.getPortsConnection().get(taskPattern)) {
- if (st[1].equals(clonedTask)) {
- st[1] = taskNameWithIndex;
- }
- }
- }
- for (String taskPattern : _patternConfiguration.getChannelsMapping().keySet()) {
- for (String[] st : _patternConfiguration.getPortsConnection().get(taskPattern)) {
- if (st[1].equals(clonedTask)) {
- st[1] = taskNameWithIndex;
- }
- }
- }
- _patternConfiguration.getChannelsMapping().put(taskNameWithIndex, _patternConfiguration.getTasksMapping().remove(clonedTask));
- _patternConfiguration.getPortsConnection().put(taskNameWithIndex, _patternConfiguration.getTasksMapping().remove(clonedTask));
- }*/
- //List<String> usedChannelsOfClonedTask = new ArrayList<String>();
- Map<String, String> oldNewChannelsClonedTaskName = new HashMap<String, String>();
- Map<String, String> oldNewEventsClonedTaskName = new HashMap<String, String>();
- List<TMLActivityElement> aeElemsToRemove = new ArrayList<TMLActivityElement>();
- for (String taskPattern : _patternConfiguration.getPortsConnection().keySet()) {
- for (String[] st : _patternConfiguration.getPortsConnection().get(taskPattern)) {
- if (st[1].equals(clonedTask) && st.length == 3) {
- if (_tmlmModel.getChannelByName(st[2]) != null) {
- int indexChannel = 0;
- String channelNameWithIndex = st[2] + indexChannel;
- while (_tmlmModel.getChannelByName(channelNameWithIndex) != null) {
- indexChannel += 1;
- channelNameWithIndex = st[2] + indexChannel;
- }
- oldNewChannelsClonedTaskName.put(st[2], channelNameWithIndex);
- TraceManager.addDev("Channel : old =" + st[2] + " New=" + channelNameWithIndex);
- st[2] = channelNameWithIndex;
- } else if (_tmlmModel.getEventByName(st[2]) != null) {
- int indexEvent = 0;
- String eventNameWithIndex = st[2] + indexEvent;
- while (_tmlmModel.getEventByName(eventNameWithIndex) != null) {
- indexEvent += 1;
- eventNameWithIndex = st[2] + indexEvent;
+ TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
+ try {
+ TMLModeling<?> _tmlmPatternClone = _tmlmPattern.deepClone();
+ for (String taskName : _patternTasks.keySet()) {
+ for (PortTaskJsonFile portTask : _patternTasks.get(taskName).internalPorts) {
+ TMLChannel channelPattern = _tmlmPatternClone.getChannelByName(portTask.getName());
+ TMLEvent eventPattern = _tmlmPatternClone.getEventByName(portTask.getName());
+ if (portTask.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ if (channelPattern != null) {
+ if (_tmlmModel.getChannelByName(channelsOfPatternIntoModel.get(Map.entry(taskName, portTask.getName()))) == null) {
+ channelPattern.setName(channelsOfPatternIntoModel.get(Map.entry(taskName, portTask.getName())));
+ channelPattern.setTasks(_tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(channelPattern.getOriginTask().getName())), _tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(channelPattern.getDestinationTask().getName())));
+ channelPattern.setPorts(new TMLPort(channelPattern.getName(), channelPattern.getReferenceObject()), new TMLPort(channelPattern.getName(), channelPattern.getReferenceObject()));
+ _tmlmModel.addChannel(channelPattern);
+ for (TMLActivityElement elem : channelPattern.getDestinationTask().getActivityDiagram().getElements()) {
+ if (elem instanceof TMLActivityElementChannel) {
+ TMLActivityElementChannel acElemChannel = (TMLActivityElementChannel) elem;
+ for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
+ if (acElemChannel.getChannel(indexChannel).getName().equals(portTask.getName())) {
+ acElemChannel.replaceChannelWith(acElemChannel.getChannel(indexChannel), channelPattern);
+ }
+ }
}
- oldNewEventsClonedTaskName.put(st[2], eventNameWithIndex);
- st[2] = eventNameWithIndex;
}
- }
- }
- }
- for (String taskOfChannelToMap : _patternConfiguration.getChannelsMapping().keySet()) {
- for (String[] st : _patternConfiguration.getChannelsMapping().get(taskOfChannelToMap)) {
- if (taskOfChannelToMap.equals(clonedTask)) {
- if (oldNewChannelsClonedTaskName.keySet().contains(st[1])) {
- st[1] = oldNewChannelsClonedTaskName.get(st[1]);
- } else if (oldNewEventsClonedTaskName.keySet().contains(st[1])) {
- st[1] = oldNewEventsClonedTaskName.get(st[1]);
- }
- }
- if (st.length == 4) {
- if (st[2].equals(clonedTask)) {
- if (oldNewChannelsClonedTaskName.keySet().contains(st[3])) {
- st[3] = oldNewChannelsClonedTaskName.get(st[3]);
- } else if (oldNewEventsClonedTaskName.keySet().contains(st[3])) {
- st[3] = oldNewEventsClonedTaskName.get(st[3]);
+ for (TMLActivityElement elem : channelPattern.getOriginTask().getActivityDiagram().getElements()) {
+ if (elem instanceof TMLActivityElementChannel) {
+ TMLActivityElementChannel acElemChannel = (TMLActivityElementChannel) elem;
+ for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
+ if (acElemChannel.getChannel(indexChannel).getName().equals(portTask.getName())) {
+ acElemChannel.replaceChannelWith(acElemChannel.getChannel(indexChannel), channelPattern);
+ }
+ }
}
}
+ //channelsFromPatternToMap.add(channelPattern);
}
- }
- }
- for (TMLActivityElement ae : taskClone.getActivityDiagram().getElements()) {
- if (ae instanceof TMLActivityElementChannel) {
- TMLActivityElementChannel aeChannel = (TMLActivityElementChannel) ae;
- for (int i=0; i < aeChannel.getNbOfChannels(); i++) {
- if (!oldNewChannelsClonedTaskName.keySet().contains(aeChannel.getChannel(i).getName())) {
- TMLActivityElement prevElem = taskClone.getActivityDiagram().getPrevious(ae);
- prevElem.setNewNext(ae, ae.getNextElement(0));
- aeElemsToRemove.add(ae);
- } else {
-
- for (TMLPort port : aeChannel.getChannel(i).getOriginPorts()) {
- port.setName(oldNewChannelsClonedTaskName.get(aeChannel.getChannel(i).getName()));
- }
- for (TMLPort port : aeChannel.getChannel(i).getDestinationPorts()) {
- port.setName(oldNewChannelsClonedTaskName.get(aeChannel.getChannel(i).getName()));
- }
- if (aeChannel.getChannel(i).getOriginPort() != null) {
- aeChannel.getChannel(i).getOriginPort().setName(oldNewChannelsClonedTaskName.get(aeChannel.getChannel(i).getName()));
- TraceManager.addDev("Port Origin New Name = " + aeChannel.getChannel(i).getOriginPort().getName());
- }
- if (aeChannel.getChannel(i).getDestinationPort() != null) {
- aeChannel.getChannel(i).getDestinationPort().setName(oldNewChannelsClonedTaskName.get(aeChannel.getChannel(i).getName()));
- }
- TraceManager.addDev("Name Channel Clone Before =" + aeChannel.getChannel(i).getName());
- aeChannel.getChannel(i).setName(oldNewChannelsClonedTaskName.get(aeChannel.getChannel(i).getName()));
- TraceManager.addDev("Name Channel Clone After =" + aeChannel.getChannel(i).getName());
- if (_tmlmModel.getChannelByName(aeChannel.getChannel(i).getName()) == null) {
- _tmlmModel.addChannel(aeChannel.getChannel(i));
- channelsFromClonedToMap.add(aeChannel.getChannel(i));
+ } else if (eventPattern != null) {
+ if (_tmlmModel.getEventByName(channelsOfPatternIntoModel.get(Map.entry(taskName, portTask.getName()))) == null) {
+ eventPattern.setName(channelsOfPatternIntoModel.get(Map.entry(taskName, portTask.getName())));
+ eventPattern.setTasks(_tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(eventPattern.getOriginTask().getName())), _tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(eventPattern.getDestinationTask().getName())));
+ eventPattern.setPorts(new TMLPort(eventPattern.getName(), eventPattern.getReferenceObject()), new TMLPort(eventPattern.getName(), eventPattern.getReferenceObject()));
+ _tmlmModel.addEvent(eventPattern);
+ for (TMLActivityElement elem : eventPattern.getDestinationTask().getActivityDiagram().getElements()) {
+ if (elem instanceof TMLActivityElementEvent) {
+ TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) elem;
+ if (acElemEvent.getEvent().getName().equals(portTask.getName())) {
+ acElemEvent.replaceEventWith(acElemEvent.getEvent(), eventPattern);
+ }
}
}
- }
- } else if (ae instanceof TMLActivityElementEvent) {
- TMLActivityElementEvent aeEvent = (TMLActivityElementEvent) ae;
- if (!oldNewEventsClonedTaskName.keySet().contains(aeEvent.getEvent().getName())) {
- TMLActivityElement prevElem = taskClone.getActivityDiagram().getPrevious(ae);
- prevElem.setNewNext(ae, ae.getNextElement(0));
- aeElemsToRemove.add(ae);
- } else {
-
- for (TMLPort port : aeEvent.getEvent().getOriginPorts()) {
- port.setName(oldNewEventsClonedTaskName.get(aeEvent.getEvent().getName()));
- }
- for (TMLPort port : aeEvent.getEvent().getDestinationPorts()) {
- port.setName(oldNewEventsClonedTaskName.get(aeEvent.getEvent().getName()));
- }
- if (aeEvent.getEvent().getOriginPort() != null) {
- aeEvent.getEvent().getOriginPort().setName(oldNewEventsClonedTaskName.get(aeEvent.getEvent().getName()));
- }
- if (aeEvent.getEvent().getDestinationPort() != null) {
- aeEvent.getEvent().getDestinationPort().setName(oldNewEventsClonedTaskName.get(aeEvent.getEvent().getName()));
- }
- aeEvent.getEvent().setName(oldNewEventsClonedTaskName.get(aeEvent.getEvent().getName()));
- if (_tmlmModel.getEventByName(aeEvent.getEvent().getName()) == null) {
- _tmlmModel.addEvent(aeEvent.getEvent());
+ for (TMLActivityElement elem : eventPattern.getOriginTask().getActivityDiagram().getElements()) {
+ if (elem instanceof TMLActivityElementEvent) {
+ TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) elem;
+ if (acElemEvent.getEvent().getName().equals(portTask.getName())) {
+ acElemEvent.replaceEventWith(acElemEvent.getEvent(), eventPattern);
+ }
+ }
}
}
}
}
- for (TMLActivityElement ae : aeElemsToRemove) {
- taskClone.getActivityDiagram().removeElement(ae);
- }
- _tmlmModel.addTask(taskClone);
- }
- } catch (TMLCheckingError err) {
-
+ }
}
+ } catch (TMLCheckingError err) {
+
}
return _tmapModel;
}
+ /*public TMLMapping<?> updatePatternTasksAttributes(TMLMapping<?> _tmapPattern, LinkedHashMap<String, TaskPattern> _patternTasks) {
+ TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
+ for (String taskName : _patternTasks.keySet()) {
+ TMLTask taskPattern = _tmlmPattern.getTMLTaskByName(taskName);
+ if (taskPattern != null) {
+ for (int i=0; i < _patternTasks.get(taskName).getAttributes().size(); i++) {
+ TMLAttribute attribTaskPattern = taskPattern.getAttributeByName(_patternTasks.get(taskName).getAttributes().get(i).getName());
+ attribTaskPattern.initialValue = _patternTasks.get(taskName).getAttributes().get(i).getValue();
+ }
+ }
+ }
+ return _tmapPattern;
+ }*/
+
+
public TMLMapping<?> addNewPortToATask(TMLMapping<?> _tmapModel, LinkedHashMap<String, TaskPattern> _patternTasks, TMLTask _taskToAddPort, String _patternTaskName, String _portPatternName, String _portTolink) {
TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
TaskPattern tp = _patternTasks.get(_patternTaskName);
TMLActivity adTaskToAddPort = _taskToAddPort.getActivityDiagram();
List<TMLActivityElement> actElemsToAdd = new ArrayList<TMLActivityElement>();
+ TMLChannel channelInModel = _tmlmModel.getChannelByName(channelsOfPatternIntoModel.get(Map.entry(_patternTaskName, _portPatternName)));
+ TMLEvent eventInModel = _tmlmModel.getEventByName(channelsOfPatternIntoModel.get(Map.entry(_patternTaskName, _portPatternName)));
for (PortTaskJsonFile pTaskJson : tp.externalPorts) {
if (pTaskJson.name.equals(_portPatternName)) {
if (pTaskJson.getMode().equals(PatternCreation.MODE_INPUT)) {
if (pTaskJson.getType().equals(PatternCreation.CHANNEL)) {
- _taskToAddPort.addWriteTMLChannel(_tmlmModel.getChannelByName(_portPatternName));
+ _taskToAddPort.addWriteTMLChannel(channelInModel);
for (TMLActivityElement acElem : adTaskToAddPort.getElements()) {
if (acElem instanceof TMLActivityElementChannel) {
TMLActivityElementChannel acElemChannel = (TMLActivityElementChannel) acElem;
for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
if (acElemChannel.getChannel(indexChannel).getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLWriteChannel wrChannel = new TMLWriteChannel(_tmlmModel.getChannelByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
+ TMLWriteChannel wrChannel = new TMLWriteChannel(channelInModel.getName(), adTaskToAddPort.getReferenceObject());
wrChannel.setNbOfSamples("1"); /// TO UPDATE
- wrChannel.addChannel(_tmlmModel.getChannelByName(_portPatternName));
+ wrChannel.addChannel(channelInModel);
wrChannel.addNext(acElem);
prevElem.setNewNext(acElem, wrChannel);
//adTaskToAddPort.addElement(wrChannel);
@@ -752,9 +600,9 @@ public class PatternIntegration implements Runnable {
TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) acElem;
if (acElemEvent.getEvent().getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLWriteChannel wrChannel = new TMLWriteChannel(_tmlmModel.getChannelByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
+ TMLWriteChannel wrChannel = new TMLWriteChannel(channelInModel.getName(), adTaskToAddPort.getReferenceObject());
wrChannel.setNbOfSamples("1"); /// TO UPDATE
- wrChannel.addChannel(_tmlmModel.getChannelByName(_portPatternName));
+ wrChannel.addChannel(channelInModel);
wrChannel.addNext(acElem);
prevElem.setNewNext(acElem, wrChannel);
//adTaskToAddPort.addElement(wrChannel);
@@ -763,24 +611,24 @@ public class PatternIntegration implements Runnable {
}
}
} else if (pTaskJson.getType().equals(PatternCreation.EVENT)) {
- _taskToAddPort.addTMLEvent(_tmlmModel.getEventByName(_portPatternName));
- _tmlmModel.getEventByName(_portPatternName).setOriginTask(_taskToAddPort);
+ _taskToAddPort.addTMLEvent(eventInModel);
+ eventInModel.setOriginTask(_taskToAddPort);
for (TMLActivityElement acElem : adTaskToAddPort.getElements()) {
if (acElem instanceof TMLActivityElementEvent) {
TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) acElem;
if (acElemEvent.getEvent().getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLSendEvent sdEvent = new TMLSendEvent(_tmlmModel.getEventByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
- sdEvent.setEvent(_tmlmModel.getEventByName(_portPatternName));
- for (TMLWaitEvent we : _tmlmModel.getEventByName(_portPatternName).getDestinationTask().getWaitEvents()) {
- if (we.getEvent().getName().equals(_tmlmModel.getEventByName(_portPatternName).getName())) {
+ TMLSendEvent sdEvent = new TMLSendEvent(eventInModel.getName(), adTaskToAddPort.getReferenceObject());
+ sdEvent.setEvent(eventInModel);
+ for (TMLWaitEvent we : eventInModel.getDestinationTask().getWaitEvents()) {
+ if (we.getEvent().getName().equals(eventInModel.getName())) {
for (String param : we.getVectorAllParams()) {
if (param.matches("-?\\d+") || param.matches("(?i)^(true|false)")) {
sdEvent.addParam(param);
} else {
sdEvent.addParam(param);
if (_taskToAddPort.getAttributeByName(param) == null) {
- _taskToAddPort.addAttribute(_tmlmModel.getEventByName(_portPatternName).getDestinationTask().getAttributeByName(param).deepClone(_tmlmModel));
+ _taskToAddPort.addAttribute(eventInModel.getDestinationTask().getAttributeByName(param).deepClone(_tmlmModel));
}
}
@@ -797,23 +645,22 @@ public class PatternIntegration implements Runnable {
for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
if (acElemChannel.getChannel(indexChannel).getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLSendEvent sdEvent = new TMLSendEvent(_tmlmModel.getEventByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
- sdEvent.setEvent(_tmlmModel.getEventByName(_portPatternName));
- for (TMLWaitEvent we : _tmlmModel.getEventByName(_portPatternName).getDestinationTask().getWaitEvents()) {
- if (we.getEvent().getName().equals(_tmlmModel.getEventByName(_portPatternName).getName())) {
+ TMLSendEvent sdEvent = new TMLSendEvent(eventInModel.getName(), adTaskToAddPort.getReferenceObject());
+ sdEvent.setEvent(eventInModel);
+ for (TMLWaitEvent we : eventInModel.getDestinationTask().getWaitEvents()) {
+ if (we.getEvent().getName().equals(eventInModel.getName())) {
for (String param : we.getVectorAllParams()) {
if (param.matches("-?\\d+") || param.matches("(?i)^(true|false)")) {
sdEvent.addParam(param);
} else {
sdEvent.addParam(param);
if (_taskToAddPort.getAttributeByName(param) == null) {
- _taskToAddPort.addAttribute(_tmlmModel.getEventByName(_portPatternName).getDestinationTask().getAttributeByName(param).deepClone(_tmlmModel));
+ _taskToAddPort.addAttribute(eventInModel.getDestinationTask().getAttributeByName(param).deepClone(_tmlmModel));
}
}
}
}
-
}
sdEvent.addNext(acElem);
prevElem.setNewNext(acElem, sdEvent);
@@ -826,16 +673,16 @@ public class PatternIntegration implements Runnable {
}
} else if (pTaskJson.getMode().equals(PatternCreation.MODE_OUTPUT)) {
if (pTaskJson.getType().equals(PatternCreation.CHANNEL)) {
- _taskToAddPort.addReadTMLChannel(_tmlmModel.getChannelByName(_portPatternName));
+ _taskToAddPort.addReadTMLChannel(channelInModel);
for (TMLActivityElement acElem : adTaskToAddPort.getElements()) {
if (acElem instanceof TMLActivityElementChannel) {
TMLActivityElementChannel acElemChannel = (TMLActivityElementChannel) acElem;
for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
if (acElemChannel.getChannel(indexChannel).getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLReadChannel rdChannel = new TMLReadChannel(_tmlmModel.getChannelByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
+ TMLReadChannel rdChannel = new TMLReadChannel(channelInModel.getName(), adTaskToAddPort.getReferenceObject());
rdChannel.setNbOfSamples("1"); /// TO UPDATE
- rdChannel.addChannel(_tmlmModel.getChannelByName(_portPatternName));
+ rdChannel.addChannel(channelInModel);
rdChannel.addNext(acElem);
prevElem.setNewNext(acElem, rdChannel);
//adTaskToAddPort.addElement(rdChannel);
@@ -846,9 +693,9 @@ public class PatternIntegration implements Runnable {
TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) acElem;
if (acElemEvent.getEvent().getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLReadChannel rdChannel = new TMLReadChannel(_tmlmModel.getChannelByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
+ TMLReadChannel rdChannel = new TMLReadChannel(channelInModel.getName(), adTaskToAddPort.getReferenceObject());
rdChannel.setNbOfSamples("1"); /// TO UPDATE
- rdChannel.addChannel(_tmlmModel.getChannelByName(_portPatternName));
+ rdChannel.addChannel(channelInModel);
rdChannel.addNext(acElem);
prevElem.setNewNext(acElem, rdChannel);
//adTaskToAddPort.addElement(rdChannel);
@@ -857,30 +704,30 @@ public class PatternIntegration implements Runnable {
}
}
} else if (pTaskJson.getType().equals(PatternCreation.EVENT)) {
- _taskToAddPort.addTMLEvent(_tmlmModel.getEventByName(_portPatternName));
- _tmlmModel.getEventByName(_portPatternName).setDestinationTask(_taskToAddPort);
+ _taskToAddPort.addTMLEvent(eventInModel);
+ eventInModel.setDestinationTask(_taskToAddPort);
for (TMLActivityElement acElem : adTaskToAddPort.getElements()) {
if (acElem instanceof TMLActivityElementEvent) {
TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) acElem;
if (acElemEvent.getEvent().getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLWaitEvent wtEvent = new TMLWaitEvent(_tmlmModel.getEventByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
- wtEvent.setEvent(_tmlmModel.getEventByName(_portPatternName));
- for (TMLSendEvent sd : _tmlmModel.getEventByName(_portPatternName).getOriginTask().getSendEvents()) {
- if (sd.getEvent().getName().equals(_tmlmModel.getEventByName(_portPatternName).getName())) {
+ TMLWaitEvent wtEvent = new TMLWaitEvent(eventInModel.getName(), adTaskToAddPort.getReferenceObject());
+ wtEvent.setEvent(eventInModel);
+ for (TMLSendEvent sd : eventInModel.getOriginTask().getSendEvents()) {
+ if (sd.getEvent().getName().equals(eventInModel.getName())) {
for (int indexParam=0; indexParam < sd.getNbOfParams(); indexParam++) {
String param = sd.getParam(indexParam);
if (param.matches("-?\\d+") || param.matches("(?i)^(true|false)")) {
- String paramName = _tmlmModel.getEventByName(_portPatternName).getName()+indexParam;
+ String paramName = eventInModel.getName()+indexParam;
if (_taskToAddPort.getAttributeByName(paramName) == null) {
- TMLAttribute attribParam = new TMLAttribute(paramName, _tmlmModel.getEventByName(_portPatternName).getParams().get(indexParam).deepClone(_tmlmModel), "");
+ TMLAttribute attribParam = new TMLAttribute(paramName, eventInModel.getParams().get(indexParam).deepClone(_tmlmModel), "");
_taskToAddPort.addAttribute(attribParam);
}
wtEvent.addParam(paramName);
} else {
wtEvent.addParam(param);
if (_taskToAddPort.getAttributeByName(param) == null) {
- _taskToAddPort.addAttribute(_tmlmModel.getEventByName(_portPatternName).getOriginTask().getAttributeByName(param).deepClone(_tmlmModel));
+ _taskToAddPort.addAttribute(eventInModel.getOriginTask().getAttributeByName(param).deepClone(_tmlmModel));
}
}
}
@@ -896,23 +743,23 @@ public class PatternIntegration implements Runnable {
for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
if (acElemChannel.getChannel(indexChannel).getName().equals(_portTolink)) {
TMLActivityElement prevElem = adTaskToAddPort.getPrevious(acElem);
- TMLWaitEvent wtEvent = new TMLWaitEvent(_tmlmModel.getEventByName(_portPatternName).getName(), adTaskToAddPort.getReferenceObject());
- wtEvent.setEvent(_tmlmModel.getEventByName(_portPatternName));
- for (TMLSendEvent sd : _tmlmModel.getEventByName(_portPatternName).getOriginTask().getSendEvents()) {
- if (sd.getEvent().getName().equals(_tmlmModel.getEventByName(_portPatternName).getName())) {
+ TMLWaitEvent wtEvent = new TMLWaitEvent(eventInModel.getName(), adTaskToAddPort.getReferenceObject());
+ wtEvent.setEvent(eventInModel);
+ for (TMLSendEvent sd : eventInModel.getOriginTask().getSendEvents()) {
+ if (sd.getEvent().getName().equals(eventInModel.getName())) {
for (int indexParam=0; indexParam < sd.getNbOfParams(); indexParam++) {
String param = sd.getParam(indexParam);
if (param.matches("-?\\d+") || param.matches("(?i)^(true|false)")) {
- String paramName = _tmlmModel.getEventByName(_portPatternName).getName()+indexParam;
+ String paramName = eventInModel.getName()+indexParam;
if (_taskToAddPort.getAttributeByName(paramName) == null) {
- TMLAttribute attribParam = new TMLAttribute(paramName, _tmlmModel.getEventByName(_portPatternName).getParams().get(indexParam).deepClone(_tmlmModel), "");
+ TMLAttribute attribParam = new TMLAttribute(paramName, eventInModel.getParams().get(indexParam).deepClone(_tmlmModel), "");
_taskToAddPort.addAttribute(attribParam);
}
wtEvent.addParam(paramName);
} else {
wtEvent.addParam(param);
if (_taskToAddPort.getAttributeByName(param) == null) {
- _taskToAddPort.addAttribute(_tmlmModel.getEventByName(_portPatternName).getOriginTask().getAttributeByName(param).deepClone(_tmlmModel));
+ _taskToAddPort.addAttribute(eventInModel.getOriginTask().getAttributeByName(param).deepClone(_tmlmModel));
}
}
}
@@ -937,7 +784,7 @@ public class PatternIntegration implements Runnable {
return _tmapModel;
}
- public TMLMapping<?> addNewPortToTasks(TMLMapping<?> _tmapModel, LinkedHashMap<String,List<String[]>> _portsConnection, LinkedHashMap<String, TaskPattern> _patternTasks) {
+ /*public TMLMapping<?> addNewPortToTasks(TMLMapping<?> _tmapModel, LinkedHashMap<String,List<String[]>> _portsConnection, LinkedHashMap<String, TaskPattern> _patternTasks) {
TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
for (String patternTaskName : _portsConnection.keySet()) {
for (String[] elemP : _portsConnection.get(patternTaskName)) {
@@ -1031,217 +878,240 @@ public class PatternIntegration implements Runnable {
}
}
return _tmapModel;
- }
+ }*/
- public TMLMapping<?> makeConnectionBetweenPatternAndModel(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, LinkedHashMap<String,List<String[]>> _portsConnection, LinkedHashMap<String, TaskPattern> _patternTasks) {
+ public TMLMapping<?> makeConnectionBetweenPatternAndModel(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, List<PatternConnection> _portsConnection, LinkedHashMap<String, TaskPattern> _patternTasks, List<PatternCloneTask> _patternCloneTasks) {
TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
TMLModeling<?> _tmlmPattern = _tmapPattern.getTMLModeling();
- for (String patternTaskName : _portsConnection.keySet()) {
- for (String[] portConn : _portsConnection.get(patternTaskName)) {
- String patternTaskPortName = portConn[0];
- String modelTaskName = portConn[1];
- String modelTaskPortName = portConn[2];
- TMLTask patternTask = _tmlmModel.getTMLTaskByName(patternTaskName);
- TMLTask modelTask = _tmlmModel.getTMLTaskByName(modelTaskName);
- TMLChannel chInModel = _tmlmModel.getChannelByName(modelTaskPortName);
- TMLEvent evtInModel = _tmlmModel.getEventByName(modelTaskPortName);
- TMLChannel chInPattern = _tmlmPattern.getChannelByName(patternTaskPortName);
- TMLEvent evtInPattern = _tmlmPattern.getEventByName(patternTaskPortName);
- TraceManager.addDev("patternTaskName = " + patternTaskName);
- TraceManager.addDev("patternTaskPortName = " + patternTaskPortName);
- TraceManager.addDev("modelTaskName = " + modelTaskName);
- TraceManager.addDev("modelTaskPortName = " + modelTaskPortName);
- TraceManager.addDev("portConn.length = " + portConn.length);
- if (chInModel == null) {
- TraceManager.addDev("chInModel == null");
+ for (PatternConnection portConnection : _portsConnection) {
+ String patternTaskName = portConnection.getPatternTaskName();
+ String patternTaskPortName = portConnection.getPatternChannel();
+ String modelTaskName = portConnection.getModelTaskName();
+ String modelTaskPortName = portConnection.getModelChannelName();
+
+ PortTaskJsonFile relatedPortInPattern = null;
+
+ for (PortTaskJsonFile portTaskJsonFile : _patternTasks.get(patternTaskName).getExternalPorts()) {
+ if (portTaskJsonFile.getName().equals(patternTaskPortName)) {
+ relatedPortInPattern = portTaskJsonFile;
+ break;
}
-
- if (portConn.length == 3) {
- if (chInModel != null) {
- if (chInPattern.getOriginTask().equals(patternTask)) {
- chInPattern.setDestinationTask(modelTask);
- chInPattern.setPorts(chInPattern.getOriginPort(), new TMLPort(chInPattern.getName(), chInPattern.getReferenceObject()));
- _tmlmModel.addChannel(chInPattern);
- channelsFromPatternToMap.add(chInPattern);
- renamedChannels.put(chInModel.getName(), chInPattern.getName());
- for (TMLActivityElement ae : modelTask.getActivityDiagram().getElements()) {
- if (ae instanceof TMLReadChannel) {
- TMLReadChannel aeRead = (TMLReadChannel) ae;
- if (aeRead.getChannel(0).getName().equals(chInModel.getName())) {
- TraceManager.addDev("replace: " + chInModel.getName() + " with " + chInPattern.getName());
- aeRead.replaceChannelWith(chInModel, chInPattern);
- }
+ }
+
+ TMLTask patternTaskInModel = _tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(patternTaskName));
+
+ if (tasksClonedIntoModel.containsKey(modelTaskName)) {
+ modelTaskName = tasksClonedIntoModel.get(modelTaskName);
+ if (!portConnection.isNewPort()) {
+ modelTaskPortName = channelsClonedIntoModel.get(Map.entry(modelTaskName, modelTaskPortName));
+ }
+ }
+ TMLTask modelTask = _tmlmModel.getTMLTaskByName(modelTaskName);
+
+ TMLChannel chInModel = _tmlmModel.getChannelByName(modelTaskPortName);
+ TMLEvent evtInModel = _tmlmModel.getEventByName(modelTaskPortName);
+
+ TMLChannel chInPattern = _tmlmPattern.getChannelByName(patternTaskPortName);
+ TMLEvent evtInPattern = _tmlmPattern.getEventByName(patternTaskPortName);
+
+ TraceManager.addDev("patternTaskName = " + patternTaskName);
+ TraceManager.addDev("patternTaskPortName = " + patternTaskPortName);
+ TraceManager.addDev("modelTaskName = " + modelTaskName);
+ TraceManager.addDev("modelTaskPortName = " + modelTaskPortName);
+ if (portConnection.isANewChannelRequired(_portsConnection, patternTasks, _patternCloneTasks)) {
+ if (chInPattern != null) {
+ TraceManager.addDev("New channel !");
+ try {
+ TMLChannel chToAdd = chInPattern.deepClone(_tmlmPattern);
+ chToAdd.setName(channelsOfPatternIntoModel.get(Map.entry(patternTaskName, patternTaskPortName)));
+ if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_INPUT)) {
+ chToAdd.setDestinationTask(patternTaskInModel);
+ chToAdd.setOriginTask(modelTask);
+ } else if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ chToAdd.setDestinationTask(modelTask);
+ chToAdd.setOriginTask(patternTaskInModel);
+ }
+ chToAdd.setPorts(new TMLPort(chToAdd.getName(), chToAdd.getReferenceObject()), new TMLPort(chToAdd.getName(), chToAdd.getReferenceObject()));
+ _tmlmModel.addChannel(chToAdd);
+
+ for (TMLActivityElement ae : patternTaskInModel.getActivityDiagram().getElements()) {
+ if (ae instanceof TMLActivityElementChannel) {
+ TMLActivityElementChannel aeCh = (TMLActivityElementChannel) ae;
+ if (aeCh.getChannel(0).getName().equals(chInPattern.getName())) {
+ aeCh.replaceChannelWith(aeCh.getChannel(0), chToAdd);
+ TraceManager.addDev("Pattern Task : Replace channel : " + chInPattern.getName() + " with : " + chToAdd.getName());
}
}
- //chInModel.setOriginTask(patternTask);
- //chInModel.setPorts(new TMLPort(chInModel.getName(), chInModel.getReferenceObject()), chInModel.getDestinationPort());
- } else if (chInModel.getOriginTask().equals(modelTask)) {
- chInModel.setDestinationTask(patternTask);
- chInModel.setPorts(chInModel.getOriginPort(), new TMLPort(chInModel.getName(), chInModel.getReferenceObject()));
- if (patternConfiguration.getChannelsWithSecurity().containsKey(patternTaskName)) {
- for (PortTaskJsonFile pt : patternConfiguration.getChannelsWithSecurity().get(patternTaskName)) {
- if (pt.getName().equals(patternTaskPortName)) {
- pt.name = chInModel.getName();
- }
- }
+ }
+ if (portConnection.isNewPort()) {
+ String modelTaskNameForNewPort = modelTaskPortName;
+ TraceManager.addDev("Before : modelTaskNameForNewPort=" + modelTaskNameForNewPort);
+ if (renamedModelChannels.containsKey(Map.entry(portConnection.getModelTaskName(), portConnection.getModelChannelName()))) {
+ modelTaskNameForNewPort = renamedModelChannels.get(Map.entry(portConnection.getModelTaskName(), portConnection.getModelChannelName()));
}
-
- for (TMLActivityElement ae : patternTask.getActivityDiagram().getElements()) {
- if (ae instanceof TMLReadChannel) {
- TMLReadChannel aeRead = (TMLReadChannel) ae;
- if (aeRead.getChannel(0).getName().equals(chInPattern.getName())) {
- aeRead.replaceChannelWith(chInPattern, chInModel);
+ TraceManager.addDev("After : modelTaskNameForNewPort=" + modelTaskNameForNewPort);
+ _tmapModel = addNewPortToATask(_tmapModel, _patternTasks, modelTask, patternTaskName, patternTaskPortName, modelTaskNameForNewPort);
+ } else {
+ for (TMLActivityElement ae : modelTask.getActivityDiagram().getElements()) {
+ if (ae instanceof TMLActivityElementChannel) {
+ TMLActivityElementChannel aeCh = (TMLActivityElementChannel) ae;
+ if (aeCh.getChannel(0).getName().equals(chInModel.getName())) {
+ aeCh.replaceChannelWith(aeCh.getChannel(0), chToAdd);
+ TraceManager.addDev("model Task : Replace channel : " + chInModel.getName() + " with : " + chToAdd.getName());
+ renamedModelChannels.put(Map.entry(portConnection.getModelTaskName(), portConnection.getModelChannelName()), chToAdd.getName());
}
}
}
}
- } else if (evtInModel != null) {
- if (evtInPattern.getOriginTask().equals(patternTask)) {
- evtInPattern.setDestinationTask(modelTask);
- evtInPattern.setPorts(evtInPattern.getOriginPort(), new TMLPort(evtInPattern.getName(), evtInPattern.getReferenceObject()));
- _tmlmModel.addEvent(evtInPattern);
- renamedChannels.put(evtInModel.getName(), evtInPattern.getName());
- for (TMLActivityElement ae : modelTask.getActivityDiagram().getElements()) {
- if (ae instanceof TMLWaitEvent) {
- TMLWaitEvent aeWait = (TMLWaitEvent) ae;
- if (aeWait.getEvent().getName().equals(evtInModel.getName())) {
- aeWait.replaceEventWith(evtInModel, evtInPattern);
- }
+ } catch (TMLCheckingError err) {
+ }
+ } else if (evtInPattern != null) {
+ TraceManager.addDev("New event !");
+ try {
+ TMLEvent evtToAdd = evtInPattern.deepClone(_tmlmPattern);
+ evtToAdd.setName(channelsOfPatternIntoModel.get(Map.entry(patternTaskName, patternTaskPortName)));
+ if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_INPUT)) {
+ evtToAdd.setDestinationTask(patternTaskInModel);
+ evtToAdd.setOriginTask(modelTask);
+ } else if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ evtToAdd.setDestinationTask(modelTask);
+ evtToAdd.setOriginTask(patternTaskInModel);
+ }
+ evtToAdd.setPorts(new TMLPort(evtToAdd.getName(), evtToAdd.getReferenceObject()), new TMLPort(evtToAdd.getName(), evtToAdd.getReferenceObject()));
+ _tmlmModel.addEvent(evtToAdd);
+
+ for (TMLActivityElement ae : patternTaskInModel.getActivityDiagram().getElements()) {
+ if (ae instanceof TMLActivityElementEvent) {
+ TMLActivityElementEvent aeEvt = (TMLActivityElementEvent) ae;
+ if (aeEvt.getEvent().getName().equals(evtInPattern.getName())) {
+ aeEvt.replaceEventWith(aeEvt.getEvent(), evtToAdd);
+ TraceManager.addDev("Pattern Task : Replace event : " + evtInPattern.getName() + " with : " + evtToAdd.getName());
}
}
- //evtInModel.setOriginTask(patternTask);
- //evtInModel.setPorts(new TMLPort(evtInModel.getName(), evtInModel.getReferenceObject()), evtInModel.getDestinationPort());
- } else if (evtInModel.getOriginTask().equals(modelTask)) {
- evtInModel.setDestinationTask(patternTask);
- evtInModel.setPorts(evtInModel.getOriginPort(), new TMLPort(evtInModel.getName(), evtInModel.getReferenceObject()));
- for (TMLActivityElement ae : patternTask.getActivityDiagram().getElements()) {
- if (ae instanceof TMLWaitEvent) {
- TMLWaitEvent aeWait = (TMLWaitEvent) ae;
- if (aeWait.getEvent().getName().equals(evtInPattern.getName())) {
- aeWait.replaceEventWith(evtInPattern, evtInModel);
+ }
+ if (portConnection.isNewPort()) {
+ String modelTaskNameForNewPort = modelTaskPortName;
+ if (renamedModelChannels.containsKey(Map.entry(portConnection.getModelTaskName(), portConnection.getModelChannelName()))) {
+ modelTaskNameForNewPort = renamedModelChannels.get(Map.entry(portConnection.getModelTaskName(), portConnection.getModelChannelName()));
+ }
+ _tmapModel = addNewPortToATask(_tmapModel, _patternTasks, modelTask, patternTaskName, patternTaskPortName, modelTaskNameForNewPort);
+ } else {
+ for (TMLActivityElement ae : modelTask.getActivityDiagram().getElements()) {
+ if (ae instanceof TMLActivityElementEvent) {
+ TMLActivityElementEvent aeEvt = (TMLActivityElementEvent) ae;
+ if (aeEvt.getEvent().getName().equals(evtInModel.getName())) {
+ aeEvt.replaceEventWith(aeEvt.getEvent(), evtToAdd);
+ TraceManager.addDev("model Task : Replace event : " + evtInModel.getName() + " with : " + evtToAdd.getName());
+ renamedModelChannels.put(Map.entry(portConnection.getModelTaskName(), portConnection.getModelChannelName()), evtToAdd.getName());
}
}
}
}
+ } catch (TMLCheckingError err) {
}
- } else if (portConn.length == 4) {
- if (chInPattern != null) {
- if (renamedChannels.containsKey(modelTaskPortName)) {
- modelTaskPortName = renamedChannels.get(modelTaskPortName);
- }
- if (chInPattern.getDestinationTask().equals(patternTask)) {
- chInPattern.setOriginTask(modelTask);
- chInPattern.setPorts(new TMLPort(chInPattern.getName(), chInPattern.getReferenceObject()), chInPattern.getDestinationPort());
- _tmlmModel.addChannel(chInPattern);
- channelsFromPatternToMap.add(chInPattern);
- _tmapModel = addNewPortToATask(_tmapModel, _patternTasks, modelTask, patternTaskName, patternTaskPortName, modelTaskPortName);
- } else if (chInPattern.getOriginTask().equals(patternTask)) {
- chInPattern.setDestinationTask(modelTask);
- chInPattern.setPorts(chInPattern.getOriginPort(), new TMLPort(chInPattern.getName(), chInPattern.getReferenceObject()));
- _tmlmModel.addChannel(chInPattern);
- channelsFromPatternToMap.add(chInPattern);
- _tmapModel = addNewPortToATask(_tmapModel, _patternTasks, modelTask, patternTaskName, patternTaskPortName, modelTaskPortName);
- }
- } else if (evtInPattern != null) {
- if (renamedChannels.containsKey(modelTaskPortName)) {
- modelTaskPortName = renamedChannels.get(modelTaskPortName);
- }
- if (evtInPattern.getDestinationTask().equals(patternTask)) {
- evtInPattern.setOriginTask(modelTask);
- evtInPattern.setPorts(new TMLPort(evtInPattern.getName(), evtInPattern.getReferenceObject()), evtInPattern.getDestinationPort());
- _tmlmModel.addEvent(evtInPattern);
- _tmapModel = addNewPortToATask(_tmapModel, _patternTasks, modelTask, patternTaskName, patternTaskPortName, modelTaskPortName);
- } else if (evtInPattern.getOriginTask().equals(patternTask)) {
- evtInPattern.setDestinationTask(modelTask);
- evtInPattern.setPorts(evtInPattern.getOriginPort(), new TMLPort(evtInPattern.getName(), evtInPattern.getReferenceObject()));
- _tmlmModel.addEvent(evtInPattern);
- _tmapModel = addNewPortToATask(_tmapModel, _patternTasks, modelTask, patternTaskName, patternTaskPortName, modelTaskPortName);
+ }
+ } else {
+ if (chInModel != null) {
+ TraceManager.addDev("Existant channel !");
+ if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_INPUT)) {
+ chInModel.setDestinationTask(patternTaskInModel);
+ chInModel.setPorts(chInModel.getOriginPort(), new TMLPort(chInModel.getName(), chInModel.getReferenceObject()));
+ } else if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ chInModel.setOriginTask(patternTaskInModel);
+ chInModel.setPorts(new TMLPort(chInModel.getName(), chInModel.getReferenceObject()), chInModel.getDestinationPort());
+ }
+
+ for (TMLActivityElement ae : patternTaskInModel.getActivityDiagram().getElements()) {
+ if (ae instanceof TMLActivityElementChannel) {
+ TMLActivityElementChannel aeCh = (TMLActivityElementChannel) ae;
+ if (aeCh.getChannel(0).getName().equals(chInPattern.getName())) {
+ aeCh.replaceChannelWith(aeCh.getChannel(0), chInModel);
+ TraceManager.addDev("Replace channel : " + chInPattern.getName() + " with : " + chInModel.getName());
+ }
}
}
}
-
+ if (evtInModel != null) {
+ TraceManager.addDev("Existant event !");
+ if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_INPUT)) {
+ evtInModel.setDestinationTask(patternTaskInModel);
+ evtInModel.setPorts(evtInModel.getOriginPort(), new TMLPort(evtInModel.getName(), evtInModel.getReferenceObject()));
+ } else if (relatedPortInPattern.getMode().equals(PatternCreation.MODE_OUTPUT)) {
+ evtInModel.setOriginTask(patternTaskInModel);
+ evtInModel.setPorts(new TMLPort(evtInModel.getName(), evtInModel.getReferenceObject()), evtInModel.getDestinationPort());
+ }
+
+ for (TMLActivityElement ae : patternTaskInModel.getActivityDiagram().getElements()) {
+ if (ae instanceof TMLActivityElementEvent) {
+ TMLActivityElementEvent aeEvt = (TMLActivityElementEvent) ae;
+ if (aeEvt.getEvent().getName().equals(evtInPattern.getName())) {
+ aeEvt.replaceEventWith(aeEvt.getEvent(), evtInModel);
+ TraceManager.addDev("Replace event : " + evtInPattern.getName() + " with : " + evtInModel.getName());
+ }
+ }
+ }
+ }
}
}
return _tmapModel;
}
- public TMLMapping<?> configDisconnectedChannels(TMLMapping<?> _tmapModel, LinkedHashMap<String, List<Entry<String, String>>> _portsConfig, HashMap<String, String> _renamedChannels) {
+ public TMLMapping<?> configDisconnectedChannels(TMLMapping<?> _tmapModel, List<PatternPortsConfig> _portsConfig) {
TMLModeling<?> _tmlmModel = _tmapModel.getTMLModeling();
TraceManager.addDev("configDisconnectedChannels");
- for (String taskName : _portsConfig.keySet()) {
- TraceManager.addDev("taskName = " + taskName);
- for (Entry<String, String> portDecision : _portsConfig.get(taskName)) {
- String portName = portDecision.getKey();
- String decision = portDecision.getValue();
- TraceManager.addDev("decision = " + decision);
- TraceManager.addDev("portName = " + portName);
- TMLTask task = _tmlmModel.getTMLTaskByName(taskName);
- if (task != null) {
- TMLActivity adTask = task.getActivityDiagram();
- TMLActivityElement elemMerge = null;
- if (decision != "") {
- for (TMLActivityElement acElem : adTask.getElements()) {
- if (acElem instanceof TMLActivityElementChannel) {
- TMLActivityElementChannel acElemChannel = (TMLActivityElementChannel) acElem;
- for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
- if (_renamedChannels.containsKey(decision)) {
- decision = _renamedChannels.get(decision);
- }
- if (acElemChannel.getChannel(indexChannel).getName().equals(decision)) {
- try {
- elemMerge = acElem.deepClone(_tmlmModel);
- } catch (TMLCheckingError err) {
-
- }
- }
- }
- } else if (acElem instanceof TMLActivityElementEvent) {
- TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) acElem;
- if (_renamedChannels.containsKey(decision)) {
- decision = _renamedChannels.get(decision);
- }
- if (acElemEvent.getEvent().getName().equals(decision)) {
- try {
- elemMerge = acElem.deepClone(_tmlmModel);
- } catch (TMLCheckingError err) {
-
- }
- }
- }
- }
+ for (PatternPortsConfig portConfig : _portsConfig) {
+ TMLTask task = _tmlmModel.getTMLTaskByName(portConfig.getTaskOfChannelToConfig());
+ //String portName = portDecision.getKey();
+ //String decision = portDecision.getValue();
+
+ if (task != null) {
+ TMLActivity adTask = task.getActivityDiagram();
+ TMLActivityElement elemMerge = null;
+ String mergeWith = portConfig.getMergeWith();
+ if (mergeWith != null) {
+ if (renamedModelChannels.containsKey(Map.entry(portConfig.getTaskOfChannelToConfig(), mergeWith))) {
+ mergeWith = renamedModelChannels.get(Map.entry(portConfig.getTaskOfChannelToConfig(), mergeWith));
}
-
- List<TMLActivityElement> elemsToRemove = new ArrayList<TMLActivityElement>();
for (TMLActivityElement acElem : adTask.getElements()) {
if (acElem instanceof TMLActivityElementChannel) {
TMLActivityElementChannel acElemChannel = (TMLActivityElementChannel) acElem;
- for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
- if (acElemChannel.getChannel(indexChannel).getName().equals(portName)) {
- TMLActivityElement prevElem = adTask.getPrevious(acElem);
- TMLActivityElement nextElem = acElem.getNextElement(0);
- if (decision.equals("")) {
- prevElem.setNewNext(acElem, nextElem);
- elemsToRemove.add(acElem);
- } else {
- try {
- TMLActivityElement newNextElem = elemMerge.deepClone(_tmlmModel);
- prevElem.setNewNext(acElem, newNextElem);
- newNextElem.clearNexts();
- newNextElem.addNext(nextElem);
- elemsToRemove.add(acElem);
- } catch (TMLCheckingError err) {
+ for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
+ if (acElemChannel.getChannel(indexChannel).getName().equals(mergeWith)) {
+ try {
+ elemMerge = acElem.deepClone(_tmlmModel);
+ } catch (TMLCheckingError err) {
- }
-
}
+ break;
}
}
} else if (acElem instanceof TMLActivityElementEvent) {
TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) acElem;
- if (acElemEvent.getEvent().getName().equals(portName)) {
+ if (acElemEvent.getEvent().getName().equals(mergeWith)) {
+ try {
+ elemMerge = acElem.deepClone(_tmlmModel);
+ } catch (TMLCheckingError err) {
+
+ }
+ break;
+ }
+ }
+ }
+ }
+
+ List<TMLActivityElement> elemsToRemove = new ArrayList<TMLActivityElement>();
+ for (TMLActivityElement acElem : adTask.getElements()) {
+ if (acElem instanceof TMLActivityElementChannel) {
+ TMLActivityElementChannel acElemChannel = (TMLActivityElementChannel) acElem;
+ for (int indexChannel = 0 ; indexChannel < acElemChannel.getNbOfChannels() ; indexChannel++) {
+ if (acElemChannel.getChannel(indexChannel).getName().equals(portConfig.getChannelToConfig())) {
TMLActivityElement prevElem = adTask.getPrevious(acElem);
TMLActivityElement nextElem = acElem.getNextElement(0);
- if (decision.equals("")) {
+ if (elemMerge == null) {
+ while (nextElem instanceof TMLActivityElementChannel && ((TMLActivityElementChannel)nextElem).getChannel(0).getName().equals(portConfig.getChannelToConfig())) {
+ elemsToRemove.add(nextElem);
+ nextElem = nextElem.getNextElement(0);
+ }
prevElem.setNewNext(acElem, nextElem);
elemsToRemove.add(acElem);
} else {
@@ -1254,87 +1124,160 @@ public class PatternIntegration implements Runnable {
} catch (TMLCheckingError err) {
}
+
}
}
}
- }
- for (TMLActivityElement elemToRemove : elemsToRemove) {
- TraceManager.addDev("elemToRemove = " + elemToRemove.getName());
- adTask.removeElement(elemToRemove);
- /*task.getReadTMLChannelSet().remove(elemToRemove);
- task.getReadTMLChannels().remove(elemToRemove);
- task.getReadChannels().remove(elemToRemove);
- task.getChannelSet().remove(elemToRemove);*/
- }
+ } else if (acElem instanceof TMLActivityElementEvent) {
+ TMLActivityElementEvent acElemEvent = (TMLActivityElementEvent) acElem;
+ if (acElemEvent.getEvent().getName().equals(portConfig.getChannelToConfig())) {
+ TMLActivityElement prevElem = adTask.getPrevious(acElem);
+ TMLActivityElement nextElem = acElem.getNextElement(0);
+ if (elemMerge == null) {
+ while (nextElem instanceof TMLActivityElementEvent && ((TMLActivityElementEvent)nextElem).getEvent().getName().equals(portConfig.getChannelToConfig())) {
+ elemsToRemove.add(nextElem);
+ nextElem = nextElem.getNextElement(0);
+ }
+ prevElem.setNewNext(acElem, nextElem);
+ elemsToRemove.add(acElem);
+ } else {
+ try {
+ TMLActivityElement newNextElem = elemMerge.deepClone(_tmlmModel);
+ prevElem.setNewNext(acElem, newNextElem);
+ newNextElem.clearNexts();
+ newNextElem.addNext(nextElem);
+ elemsToRemove.add(acElem);
+ } catch (TMLCheckingError err) {
- TraceManager.addDev("task.getReadTMLChannelSet().size() = " + task.getReadTMLChannelSet().size());
- TraceManager.addDev("task.getReadTMLChannels().size() = " + task.getReadTMLChannels().size());
- TraceManager.addDev("task.getReadChannels().size() = " + task.getReadChannels().size());
- TraceManager.addDev("task.getChannels().size() = " + task.getChannelSet().size());
- TraceManager.addDev("task.getTMLEvents().size() = " + task.getTMLEvents().size());
- TraceManager.addDev("task.getEventSet().size() = " + task.getEventSet().size());
- TraceManager.addDev("task.getSendEvents().size() = " + task.getSendEvents().size());
- TraceManager.addDev("task.getWaitEvents().size() = " + task.getWaitEvents().size());
- for (TMLActivityElement acElem : adTask.getElements()) {
- TraceManager.addDev("acElem = " + acElem.getName());
+ }
+ }
+ }
}
}
-
- }
-
+ for (TMLActivityElement elemToRemove : elemsToRemove) {
+ TraceManager.addDev("elemToRemove = " + elemToRemove.getName());
+ adTask.removeElement(elemToRemove);
+ }
+ }
}
return _tmapModel;
}
- public TMLMapping<?> mapTasksInArch(TMLMapping<?> _tmapModel, LinkedHashMap<String, Entry<String, String>> _taskMapping) {
+ public TMLMapping<?> mapTasksInArch(TMLMapping<?> _tmapModel, List<MappingPatternTask> _tasksMapping) {
TMLArchitecture _tmlarchModel = _tmapModel.getArch();
- for (String taskName : _taskMapping.keySet()) {
- String modeMapping = _taskMapping.get(taskName).getKey();
- String relatedMapping = _taskMapping.get(taskName).getValue();
- TMLTask taskToMap = _tmapModel.getTaskByName(taskName);
- if (taskToMap != null) {
- if (modeMapping.equals(JDialogPatternHandling.SAME_HW)) {
- TMLTask inSameTask = _tmapModel.getTaskByName(relatedMapping);
- if (inSameTask != null) {
- HwExecutionNode hwMapTask = _tmapModel.getHwNodeOf(inSameTask);
- if (hwMapTask != null) {
- _tmapModel.addTaskToHwExecutionNode(taskToMap, hwMapTask);
+ for (MappingPatternTask taskMapping : _tasksMapping) {
+ if (taskMapping.getOrigin() == MappingPatternTask.ORIGIN_CLONE) {
+ TMLTask taskCloneToMap = _tmapModel.getTaskByName(tasksClonedIntoModel.get(taskMapping.getTaskToMapName()));
+ if (taskCloneToMap != null) {
+ if (taskMapping.getSameHwAs() != null) {
+ String sameTaskName = taskMapping.getSameHwAs();
+ int sameTaskOrigin = taskMapping.getSameHwAsOrigin();
+ TMLTask inSameTask = null;
+ if (sameTaskOrigin == MappingPatternTask.ORIGIN_MODEL) {
+ inSameTask = _tmapModel.getTaskByName(sameTaskName);
+ } else if (sameTaskOrigin == MappingPatternTask.ORIGIN_CLONE) {
+ inSameTask = _tmapModel.getTaskByName(tasksClonedIntoModel.get(sameTaskName));
+ } else if (sameTaskOrigin == MappingPatternTask.ORIGIN_PATTERN) {
+ inSameTask = _tmapModel.getTaskByName(tasksOfPatternIntoModel.get(sameTaskName));
+ }
+ if (inSameTask != null) {
+ HwExecutionNode hwMapTask = _tmapModel.getHwNodeOf(inSameTask);
+ if (hwMapTask != null) {
+ _tmapModel.addTaskToHwExecutionNode(taskCloneToMap, hwMapTask);
+ }
+ }
+ } else if (taskMapping.getBusNameForNewHw() != null) {
+ HwBus bus = _tmlarchModel.getHwBusByName(taskMapping.getBusNameForNewHw());
+ if (bus != null) {
+ String nameCPU = "CPU_" + tasksClonedIntoModel.get(taskMapping.getTaskToMapName());
+ HwNode node = _tmlarchModel.getHwNodeByName(nameCPU);
+ if (node != null) {
+ int indexCPU = 0;
+ String nameCPUWithIndex = nameCPU + indexCPU;
+ while(_tmlarchModel.getHwNodeByName(nameCPUWithIndex) != null) {
+ indexCPU += 1;
+ nameCPUWithIndex = nameCPU + indexCPU;
+ }
+ nameCPU = nameCPUWithIndex;
+ }
+ HwCPU _newCpu = new HwCPU(nameCPU);
+ _tmapModel.addTaskToHwExecutionNode(taskCloneToMap, _newCpu);
+ _tmlarchModel.addHwNode(_newCpu);
+ HwLink linkNewCPUWithBus = new HwLink("link_" + _newCpu.getName() + "_to_" + bus.getName());
+ linkNewCPUWithBus.bus = bus;
+ linkNewCPUWithBus.hwnode = _newCpu;
+ _tmlarchModel.addHwLink(linkNewCPUWithBus);
}
}
- } else if (modeMapping.equals(JDialogPatternHandling.NEW_HW)) {
- HwBus bus = _tmlarchModel.getHwBusByName(relatedMapping);
- if (bus != null) {
- String nameCPU = "CPU_" + taskName;
- HwNode node = _tmlarchModel.getHwNodeByName(nameCPU);
- if (node != null) {
- int indexCPU = 0;
- String nameCPUWithIndex = nameCPU + indexCPU;
- while(_tmlarchModel.getHwNodeByName(nameCPUWithIndex) != null) {
- indexCPU += 1;
- nameCPUWithIndex = nameCPU + indexCPU;
+ }
+ } else if (taskMapping.getOrigin() == MappingPatternTask.ORIGIN_PATTERN) {
+ TMLTask taskPatternToMap = _tmapModel.getTaskByName(tasksOfPatternIntoModel.get(taskMapping.getTaskToMapName()));
+ if (taskPatternToMap != null) {
+ if (taskMapping.getSameHwAs() != null) {
+ String sameTaskName = taskMapping.getSameHwAs();
+ int sameTaskOrigin = taskMapping.getSameHwAsOrigin();
+ TMLTask inSameTask = null;
+ if (sameTaskOrigin == MappingPatternTask.ORIGIN_MODEL) {
+ inSameTask = _tmapModel.getTaskByName(sameTaskName);
+ } else if (sameTaskOrigin == MappingPatternTask.ORIGIN_CLONE) {
+ inSameTask = _tmapModel.getTaskByName(tasksClonedIntoModel.get(sameTaskName));
+ } else if (sameTaskOrigin == MappingPatternTask.ORIGIN_PATTERN) {
+ inSameTask = _tmapModel.getTaskByName(tasksOfPatternIntoModel.get(sameTaskName));
+ }
+ if (inSameTask != null) {
+ HwExecutionNode hwMapTask = _tmapModel.getHwNodeOf(inSameTask);
+ if (hwMapTask != null) {
+ _tmapModel.addTaskToHwExecutionNode(taskPatternToMap, hwMapTask);
+ }
+ }
+ } else if (taskMapping.getBusNameForNewHw() != null) {
+ HwBus bus = _tmlarchModel.getHwBusByName(taskMapping.getBusNameForNewHw());
+ if (bus != null) {
+ String nameCPU = "CPU_" + tasksOfPatternIntoModel.get(taskMapping.getTaskToMapName());
+ HwNode node = _tmlarchModel.getHwNodeByName(nameCPU);
+ if (node != null) {
+ int indexCPU = 0;
+ String nameCPUWithIndex = nameCPU + indexCPU;
+ while(_tmlarchModel.getHwNodeByName(nameCPUWithIndex) != null) {
+ indexCPU += 1;
+ nameCPUWithIndex = nameCPU + indexCPU;
+ }
+ nameCPU = nameCPUWithIndex;
}
- nameCPU = nameCPUWithIndex;
+ HwCPU _newCpu = new HwCPU(nameCPU);
+ _tmapModel.addTaskToHwExecutionNode(taskPatternToMap, _newCpu);
+ _tmlarchModel.addHwNode(_newCpu);
+ HwLink linkNewCPUWithBus = new HwLink("link_" + _newCpu.getName() + "_to_" + bus.getName());
+ linkNewCPUWithBus.bus = bus;
+ linkNewCPUWithBus.hwnode = _newCpu;
+ _tmlarchModel.addHwLink(linkNewCPUWithBus);
}
- HwCPU _newCpu = new HwCPU(nameCPU);
- _tmapModel.addTaskToHwExecutionNode(taskToMap, _newCpu);
- _tmlarchModel.addHwNode(_newCpu);
- HwLink linkNewCPUWithBus = new HwLink("link_" + _newCpu.getName() + "_to_" + bus.getName());
- linkNewCPUWithBus.bus = bus;
- linkNewCPUWithBus.hwnode = _newCpu;
- _tmlarchModel.addHwLink(linkNewCPUWithBus);
}
}
}
+
+
+
}
return _tmapModel;
}
- public TMLMapping<?> mapTasksInArchAuto(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, Set<String> mappedTasks, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks) {
+ public TMLMapping<?> mapTasksInArchAuto(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, List<MappingPatternTask> _mappingPatternTasks, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks) {
TMLModeling<?> tmlmModel = _tmapModel.getTMLModeling();
TMLModeling<?> tmlmPattern = _tmapPattern.getTMLModeling();
Map<TMLTask, TMLTask> correspTasks = correspondenceForTasks(_tmapModel, _tmapPattern, _patternConfiguration, _patternTasks);
+ Set<String> mappedTasks = new HashSet<String>();
+ for (MappingPatternTask mappingPatternTask : _mappingPatternTasks) {
+ mappedTasks.add(mappingPatternTask.getTaskToMapName());
+ }
Map<TMLTask, TMLTask> correspondenceForClonedTasks = correspondenceForClonedTasks(_tmapModel, _tmapPattern, mappedTasks, _patternConfiguration, _patternTasks);
+ for (TMLTask correspTask : correspTasks.keySet()) {
+ TraceManager.addDev("correspTask: In pattern :" + correspTask.getName() + " In model : " + correspTasks.get(correspTask).getName());
+ }
+ for (TMLTask correspTask : correspondenceForClonedTasks.keySet()) {
+ TraceManager.addDev("correspondenceForClonedTasks: In Model :" + correspTask.getName() + " In pattern : " + correspondenceForClonedTasks.get(correspTask).getName());
+ }
LinkedHashMap<String, TaskPattern> _patternTasksSorted = new LinkedHashMap<String, TaskPattern>();
LinkedHashMap<String, TaskPattern> _patternTasksInEnd = new LinkedHashMap<String, TaskPattern>();
for (String taskName : _patternTasks.keySet()) {
@@ -1345,177 +1288,182 @@ public class PatternIntegration implements Runnable {
}
}
_patternTasksSorted.putAll(_patternTasksInEnd);
- outerloop:
for (String taskName : _patternTasksSorted.keySet()) {
TMLTask task = tmlmPattern.getTMLTaskByName(taskName);
+ boolean taskIsMapped = false;
if (task != null && !mappedTasks.contains(taskName)) {
HwExecutionNode hwMapTask = _tmapPattern.getHwNodeOf(task);
HashSet<TMLTask> tasksInThisCPU = _tmapPattern.getLisMappedTasks(hwMapTask);
for (TMLTask taskInCPU : tasksInThisCPU) {
- if (_patternTasks.containsKey(taskInCPU.getName())) {
- TMLTask taskInModel = tmlmModel.getTMLTaskByName(taskInCPU.getName());
- HwExecutionNode hwMapTaskInModel = _tmapModel.getHwNodeOf(taskInModel);
- if (hwMapTaskInModel != null) {
- TMLTask taskToMap = tmlmModel.getTMLTaskByName(taskName);
- _tmapModel.addTaskToHwExecutionNode(taskToMap, hwMapTaskInModel);
- break outerloop;
- }
- } else if (correspTasks.containsKey(taskInCPU)) {
- TMLTask taskInModel = tmlmModel.getTMLTaskByName((correspTasks.get(taskInCPU)).getName());
+ if (correspTasks.containsKey(taskInCPU)) {
+ TMLTask taskInModel = correspTasks.get(taskInCPU);
HwExecutionNode hwMapTaskInModel = _tmapModel.getHwNodeOf(taskInModel);
if (hwMapTaskInModel != null) {
- TMLTask taskToMap = tmlmModel.getTMLTaskByName(taskName);
+ TMLTask taskToMap = tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(taskName));
_tmapModel.addTaskToHwExecutionNode(taskToMap, hwMapTaskInModel);
- break outerloop;
+ taskIsMapped = true;
+ break;
}
}
}
- String nameNewCPU = hwMapTask.getName();
- HwExecutionNode newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
- int ind = 0;
- while (newCPU != null) {
- nameNewCPU = hwMapTask.getName() + ind;
- newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
- ind += 1;
- }
- HwCPU _newCpu = new HwCPU(nameNewCPU);
- TMLTask taskToMap = tmlmModel.getTMLTaskByName(taskName);
- _tmapModel.addTaskToHwExecutionNode(taskToMap, _newCpu);
- _tmapModel.getArch().addHwNode(_newCpu);
- HwBus bus = null;
- for (TMLChannel ch : tmlmModel.getChannelsFromMe(taskToMap)) {
- TMLTask taskInConn = ch.getDestinationTask();
- HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
- if (hwOfTaskInConn != null) {
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.hwnode == hwOfTaskInConn) {
- bus = link.bus;
+ if (!taskIsMapped) {
+ String nameNewCPU = hwMapTask.getName();
+ HwExecutionNode newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
+ int ind = 0;
+ while (newCPU != null) {
+ nameNewCPU = hwMapTask.getName() + ind;
+ newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
+ ind += 1;
+ }
+ HwCPU _newCpu = new HwCPU(nameNewCPU);
+ TMLTask taskToMap = tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(taskName));
+ _tmapModel.addTaskToHwExecutionNode(taskToMap, _newCpu);
+ _tmapModel.getArch().addHwNode(_newCpu);
+ HwBus bus = null;
+ for (TMLChannel ch : tmlmModel.getChannelsFromMe(taskToMap)) {
+ if (bus == null) {
+ TMLTask taskInConn = ch.getDestinationTask();
+ HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
+ if (hwOfTaskInConn != null) {
+ for (HwLink link : _tmapModel.getArch().getHwLinks()) {
+ if (link.hwnode == hwOfTaskInConn) {
+ bus = link.bus;
+ break;
+ }
+ }
}
}
}
- }
- for (TMLChannel ch : tmlmModel.getChannelsToMe(taskToMap)) {
- TMLTask taskInConn = ch.getOriginTask();
- HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
- if (hwOfTaskInConn != null) {
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.hwnode == hwOfTaskInConn) {
- bus = link.bus;
+
+ for (TMLChannel ch : tmlmModel.getChannelsToMe(taskToMap)) {
+ if (bus == null) {
+ TMLTask taskInConn = ch.getOriginTask();
+ HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
+ if (hwOfTaskInConn != null) {
+ for (HwLink link : _tmapModel.getArch().getHwLinks()) {
+ if (link.hwnode == hwOfTaskInConn) {
+ bus = link.bus;
+ break;
+ }
+ }
}
}
}
- }
- if (bus == null) {
- int nbConnections = 0 ;
- for (HwNode busModel : _tmapModel.getArch().getBUSs()) {
- if (busModel instanceof HwBus) {
- int curNbConnections = 0 ;
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.bus == busModel) {
- nbConnections += 1;
+
+ if (bus == null) {
+ int nbConnections = 0 ;
+ for (HwNode busModel : _tmapModel.getArch().getBUSs()) {
+ if (busModel instanceof HwBus) {
+ int curNbConnections = 0 ;
+ for (HwLink link : _tmapModel.getArch().getHwLinks()) {
+ if (link.bus == busModel) {
+ nbConnections += 1;
+ }
+ }
+ if (curNbConnections > nbConnections) {
+ bus = (HwBus) busModel;
+ nbConnections = curNbConnections;
}
- }
- if (curNbConnections > nbConnections) {
- bus = (HwBus) busModel;
- nbConnections = curNbConnections;
}
}
}
+ HwLink linkNewCPUWithBus = new HwLink("link_" + _newCpu.getName() + "_to_" + bus.getName());
+ linkNewCPUWithBus.bus = bus;
+ linkNewCPUWithBus.hwnode = _newCpu;
+ _tmapModel.getArch().addHwLink(linkNewCPUWithBus);
}
-
- HwLink linkNewCPUWithBus = new HwLink("link_" + _newCpu.getName() + "_to_" + bus.getName());
- linkNewCPUWithBus.bus = bus;
- linkNewCPUWithBus.hwnode = _newCpu;
- _tmapModel.getArch().addHwLink(linkNewCPUWithBus);
}
}
- outerloop1:
- for (String taskName : _patternConfiguration.getClonedTasks().keySet()) {
+
+ for (PatternCloneTask patternCloneTask : _patternConfiguration.getClonedTasks()) {
+ String taskName = tasksClonedIntoModel.get(patternCloneTask.getClonedTask());
TMLTask task = tmlmModel.getTMLTaskByName(taskName);
- if (task != null && !mappedTasks.contains(taskName)) {
+ boolean taskIsMapped = false;
+ if (task != null && !mappedTasks.contains(patternCloneTask.getClonedTask())) {
TMLTask taskInPattern = correspondenceForClonedTasks.get(task);
HwExecutionNode hwMapTask = _tmapPattern.getHwNodeOf(taskInPattern);
HashSet<TMLTask> tasksInThisCPU = _tmapPattern.getLisMappedTasks(hwMapTask);
for (TMLTask taskInCPU : tasksInThisCPU) {
- if (_patternTasks.containsKey(taskInCPU.getName())) {
- TMLTask taskInModel = tmlmModel.getTMLTaskByName(taskInCPU.getName());
- HwExecutionNode hwMapTaskInModel = _tmapModel.getHwNodeOf(taskInModel);
- if (hwMapTaskInModel != null) {
- _tmapModel.addTaskToHwExecutionNode(task, hwMapTaskInModel);
- break outerloop1;
- }
- } else if (correspTasks.containsKey(taskInCPU)) {
- TMLTask taskInModel = tmlmModel.getTMLTaskByName((correspTasks.get(taskInCPU)).getName());
+ if (correspTasks.containsKey(taskInCPU)) {
+ TMLTask taskInModel = correspTasks.get(taskInCPU);
HwExecutionNode hwMapTaskInModel = _tmapModel.getHwNodeOf(taskInModel);
if (hwMapTaskInModel != null) {
_tmapModel.addTaskToHwExecutionNode(task, hwMapTaskInModel);
- break outerloop1;
+ taskIsMapped = true;
+ break;
}
}
}
- String nameNewCPU = hwMapTask.getName();
- HwExecutionNode newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
- int ind = 0;
- while (newCPU != null) {
- nameNewCPU = hwMapTask.getName() + ind;
- newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
- ind += 1;
- }
- HwCPU _newCpu = new HwCPU(nameNewCPU);
- TMLTask taskToMap = tmlmModel.getTMLTaskByName(taskName);
- _tmapModel.addTaskToHwExecutionNode(taskToMap, _newCpu);
- _tmapModel.getArch().addHwNode(_newCpu);
+ if (!taskIsMapped) {
+ String nameNewCPU = hwMapTask.getName();
+ HwExecutionNode newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
+ int ind = 0;
+ while (newCPU != null) {
+ nameNewCPU = hwMapTask.getName() + ind;
+ newCPU = _tmapModel.getHwExecutionNodeByName(nameNewCPU);
+ ind += 1;
+ }
+ HwCPU _newCpu = new HwCPU(nameNewCPU);
+ TMLTask taskToMap = tmlmModel.getTMLTaskByName(taskName);
+ _tmapModel.addTaskToHwExecutionNode(taskToMap, _newCpu);
+ _tmapModel.getArch().addHwNode(_newCpu);
- HwBus bus = null;
- for (TMLChannel ch : tmlmModel.getChannelsFromMe(taskToMap)) {
- TMLTask taskInConn = ch.getDestinationTask();
- HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
- if (hwOfTaskInConn != null) {
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.hwnode == hwOfTaskInConn) {
- bus = link.bus;
+ HwBus bus = null;
+ for (TMLChannel ch : tmlmModel.getChannelsFromMe(taskToMap)) {
+ if (bus == null) {
+ TMLTask taskInConn = ch.getDestinationTask();
+ HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
+ if (hwOfTaskInConn != null) {
+ for (HwLink link : _tmapModel.getArch().getHwLinks()) {
+ if (link.hwnode == hwOfTaskInConn) {
+ bus = link.bus;
+ break;
+ }
+ }
}
}
+
}
- }
- for (TMLChannel ch : tmlmModel.getChannelsToMe(taskToMap)) {
- TMLTask taskInConn = ch.getOriginTask();
- HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
- if (hwOfTaskInConn != null) {
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.hwnode == hwOfTaskInConn) {
- bus = link.bus;
+ for (TMLChannel ch : tmlmModel.getChannelsToMe(taskToMap)) {
+ if (bus == null) {
+ TMLTask taskInConn = ch.getOriginTask();
+ HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
+ if (hwOfTaskInConn != null) {
+ for (HwLink link : _tmapModel.getArch().getHwLinks()) {
+ if (link.hwnode == hwOfTaskInConn) {
+ bus = link.bus;
+ break;
+ }
+ }
}
}
}
- }
- if (bus == null) {
- int nbConnections = 0 ;
- for (HwNode busModel : _tmapModel.getArch().getBUSs()) {
- if (busModel instanceof HwBus) {
- int curNbConnections = 0 ;
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.bus == busModel) {
- nbConnections += 1;
+ if (bus == null) {
+ int nbConnections = 0 ;
+ for (HwNode busModel : _tmapModel.getArch().getBUSs()) {
+ if (busModel instanceof HwBus) {
+ int curNbConnections = 0 ;
+ for (HwLink link : _tmapModel.getArch().getHwLinks()) {
+ if (link.bus == busModel) {
+ nbConnections += 1;
+ }
+ }
+ if (curNbConnections > nbConnections) {
+ bus = (HwBus) busModel;
+ nbConnections = curNbConnections;
}
- }
- if (curNbConnections > nbConnections) {
- bus = (HwBus) busModel;
- nbConnections = curNbConnections;
}
}
}
+ HwLink linkNewCPUWithBus = new HwLink("link_" + _newCpu.getName() + "_to_" + bus.getName());
+ linkNewCPUWithBus.bus = bus;
+ linkNewCPUWithBus.hwnode = _newCpu;
+ _tmapModel.getArch().addHwLink(linkNewCPUWithBus);
}
- HwLink linkNewCPUWithBus = new HwLink("link_" + _newCpu.getName() + "_to_" + bus.getName());
- linkNewCPUWithBus.bus = bus;
- linkNewCPUWithBus.hwnode = _newCpu;
- _tmapModel.getArch().addHwLink(linkNewCPUWithBus);
-
}
}
-
return _tmapModel;
}
@@ -1525,8 +1473,9 @@ public class PatternIntegration implements Runnable {
TMLModeling<?> tmlmPattern = _tmapPattern.getTMLModeling();
List <String> clonedTasksToMap = new ArrayList<String>();
// List <TMLTask> patternTasksToMap = new ArrayList<TMLTask>();
- for (String taskName : _patternConfiguration.getClonedTasks().keySet()) {
- TMLTask task = tmlmModel.getTMLTaskByName(taskName);
+ for (PatternCloneTask patternCloneTask : _patternConfiguration.getClonedTasks()) {
+ String taskName = patternCloneTask.getClonedTask();
+ TMLTask task = tmlmModel.getTMLTaskByName(tasksClonedIntoModel.get(taskName));
if (task != null && !mappedTasks.contains(taskName)) {
clonedTasksToMap.add(task.getName());
}
@@ -1538,81 +1487,35 @@ public class PatternIntegration implements Runnable {
}
} */
Map<TMLTask, TMLTask> correspTasks = new HashMap<TMLTask, TMLTask>();
- for (String taskPatternName : _patternConfiguration.getPortsConnection().keySet()) {
- for (String[] pc : _patternConfiguration.getPortsConnection().get(taskPatternName)) {
- if (clonedTasksToMap.contains(pc[1])) {
-
- String modeChInPattern = "";
- String typeChInPattern = "";
- for (PortTaskJsonFile pt : _patternTasks.get(taskPatternName).getExternalPorts()) {
- if (pt.getName().equals(pc[0])) {
- modeChInPattern = pt.getMode();
- typeChInPattern = pt.getType();
- break;
- }
- }
- if (typeChInPattern.equals(PatternCreation.CHANNEL)) {
- TMLChannel chInPattern = tmlmPattern.getChannelByName(pc[0]);
- if (chInPattern != null) {
- if (modeChInPattern.equals(PatternCreation.MODE_INPUT)) {
- correspTasks.put(tmlmModel.getTMLTaskByName(pc[1]), chInPattern.getOriginTask());
- } else if (modeChInPattern.equals(PatternCreation.MODE_OUTPUT)) {
- correspTasks.put(tmlmModel.getTMLTaskByName(pc[1]), chInPattern.getDestinationTask());
- }
-
- }
- } else if (typeChInPattern.equals(PatternCreation.EVENT)) {
- TMLEvent evtInPattern = tmlmPattern.getEventByName(pc[0]);
- if (evtInPattern != null) {
- if (modeChInPattern.equals(PatternCreation.MODE_INPUT)) {
- correspTasks.put(tmlmModel.getTMLTaskByName(pc[1]), evtInPattern.getOriginTask());
- } else if (modeChInPattern.equals(PatternCreation.MODE_OUTPUT)) {
- correspTasks.put(tmlmModel.getTMLTaskByName(pc[1]), evtInPattern.getDestinationTask());
- }
-
- }
- }
- }
- }
- }
- return correspTasks;
- }
-
- // Find correspondence between Tasks of the pattern model and the tasks of current Model
- public Map<TMLTask, TMLTask> correspondenceForTasks(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks) {
- TMLModeling<?> tmlmModel = _tmapModel.getTMLModeling();
- TMLModeling<?> tmlmPattern = _tmapPattern.getTMLModeling();
- Map<TMLTask, TMLTask> correspTasks = new HashMap<TMLTask, TMLTask>();
- for (String taskPatternName : _patternConfiguration.getPortsConnection().keySet()) {
- for (String[] pc : _patternConfiguration.getPortsConnection().get(taskPatternName)) {
-
+ for (PatternConnection patternConnection : _patternConfiguration.getPortsConnection()) {
+ String taskPatternName = patternConnection.getPatternTaskName();
+ if (clonedTasksToMap.contains(tasksClonedIntoModel.get(patternConnection.getModelTaskName()))) {
String modeChInPattern = "";
String typeChInPattern = "";
for (PortTaskJsonFile pt : _patternTasks.get(taskPatternName).getExternalPorts()) {
- if (pt.getName().equals(pc[0])) {
+ if (pt.getName().equals(patternConnection.getPatternChannel())) {
modeChInPattern = pt.getMode();
typeChInPattern = pt.getType();
break;
}
}
-
-
if (typeChInPattern.equals(PatternCreation.CHANNEL)) {
- TMLChannel chInPattern = tmlmPattern.getChannelByName(pc[0]);
+ TMLChannel chInPattern = tmlmPattern.getChannelByName(patternConnection.getPatternChannel());
if (chInPattern != null) {
if (modeChInPattern.equals(PatternCreation.MODE_INPUT)) {
- correspTasks.put(chInPattern.getOriginTask(), tmlmModel.getTMLTaskByName(pc[1]));
+ correspTasks.put(tmlmModel.getTMLTaskByName(tasksClonedIntoModel.get(patternConnection.getModelTaskName())), chInPattern.getOriginTask());
} else if (modeChInPattern.equals(PatternCreation.MODE_OUTPUT)) {
- correspTasks.put(chInPattern.getDestinationTask(), tmlmModel.getTMLTaskByName(pc[1]));
+ correspTasks.put(tmlmModel.getTMLTaskByName(tasksClonedIntoModel.get(patternConnection.getModelTaskName())), chInPattern.getDestinationTask());
}
+
}
} else if (typeChInPattern.equals(PatternCreation.EVENT)) {
- TMLEvent evtInPattern = tmlmPattern.getEventByName(pc[0]);
+ TMLEvent evtInPattern = tmlmPattern.getEventByName(patternConnection.getPatternChannel());
if (evtInPattern != null) {
if (modeChInPattern.equals(PatternCreation.MODE_INPUT)) {
- correspTasks.put(evtInPattern.getOriginTask(), tmlmModel.getTMLTaskByName(pc[1]));
+ correspTasks.put(tmlmModel.getTMLTaskByName(tasksClonedIntoModel.get(patternConnection.getModelTaskName())), evtInPattern.getOriginTask());
} else if (modeChInPattern.equals(PatternCreation.MODE_OUTPUT)) {
- correspTasks.put(evtInPattern.getDestinationTask(), tmlmModel.getTMLTaskByName(pc[1]));
+ correspTasks.put(tmlmModel.getTMLTaskByName(tasksClonedIntoModel.get(patternConnection.getModelTaskName())), evtInPattern.getDestinationTask());
}
}
}
@@ -1621,104 +1524,177 @@ public class PatternIntegration implements Runnable {
return correspTasks;
}
+ // Find correspondence between Tasks of the pattern model and the tasks of current Model
+ public Map<TMLTask, TMLTask> correspondenceForTasks(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks) {
+ TMLModeling<?> tmlmModel = _tmapModel.getTMLModeling();
+ TMLModeling<?> tmlmPattern = _tmapPattern.getTMLModeling();
+ Map<TMLTask, TMLTask> correspTasks = new HashMap<TMLTask, TMLTask>();
+ for (PatternConnection patternConnection : _patternConfiguration.getPortsConnection()) {
+ String taskPatternName = patternConnection.getPatternTaskName();
+ String modelTask = patternConnection.getModelTaskName();
+ if (tasksClonedIntoModel.containsKey(modelTask)) {
+ modelTask = tasksClonedIntoModel.get(modelTask);
+ }
+ String modeChInPattern = "";
+ String typeChInPattern = "";
+ for (PortTaskJsonFile pt : _patternTasks.get(taskPatternName).getExternalPorts()) {
+ if (pt.getName().equals(patternConnection.getPatternChannel())) {
+ modeChInPattern = pt.getMode();
+ typeChInPattern = pt.getType();
+ break;
+ }
+ }
+ if (typeChInPattern.equals(PatternCreation.CHANNEL)) {
+ TMLChannel chInPattern = tmlmPattern.getChannelByName(patternConnection.getPatternChannel());
+ if (chInPattern != null) {
+ if (modeChInPattern.equals(PatternCreation.MODE_INPUT)) {
+ correspTasks.put(chInPattern.getOriginTask(), tmlmModel.getTMLTaskByName(modelTask));
+ } else if (modeChInPattern.equals(PatternCreation.MODE_OUTPUT)) {
+ correspTasks.put(chInPattern.getDestinationTask(), tmlmModel.getTMLTaskByName(modelTask));
+ }
+ }
+ } else if (typeChInPattern.equals(PatternCreation.EVENT)) {
+ TMLEvent evtInPattern = tmlmPattern.getEventByName(patternConnection.getPatternChannel());
+ if (evtInPattern != null) {
+ if (modeChInPattern.equals(PatternCreation.MODE_INPUT)) {
+ correspTasks.put(evtInPattern.getOriginTask(), tmlmModel.getTMLTaskByName(modelTask));
+ } else if (modeChInPattern.equals(PatternCreation.MODE_OUTPUT)) {
+ correspTasks.put(evtInPattern.getDestinationTask(), tmlmModel.getTMLTaskByName(modelTask));
+ }
+ }
+ }
+ }
+ for (String patternTask: _patternTasks.keySet()) {
+ correspTasks.put(tmlmPattern.getTMLTaskByName(patternTask), tmlmModel.getTMLTaskByName(tasksOfPatternIntoModel.get(patternTask)));
+ }
+ return correspTasks;
+ }
+
- public TMLMapping<?> mapChannelsInArch(TMLMapping<?> _tmapModel, LinkedHashMap<String, List<String[]>> _channelMapping) {
+ public TMLMapping<?> mapChannelsInArch(TMLMapping<?> _tmapModel, List<MappingPatternChannel> _channelMapping) {
TMLArchitecture _tmlarchModel = _tmapModel.getArch();
- for (String taskName : _channelMapping.keySet()) {
- for (String[] channelMap : _channelMapping.get(taskName)) {
- String modeMapping = channelMap[0];
- String channelToMapName = channelMap[1];
- if (renamedChannels.containsKey(channelToMapName)) {
- channelToMapName = renamedChannels.get(channelToMapName);
- }
-
- TMLChannel channelToMap = _tmapModel.getChannelByName(channelToMapName);
- TraceManager.addDev("channelToMapName= " + channelToMapName);
- if (channelToMap != null) {
- TraceManager.addDev("channelToMap != null");
- if (modeMapping.equals(JDialogPatternHandling.SAME_MEMORY)) {
- String sameChannel = channelMap[3];
- if (renamedChannels.containsKey(sameChannel)) {
- sameChannel = renamedChannels.get(sameChannel);
- }
- TraceManager.addDev("sameChannel= " + sameChannel);
- TMLChannel inSameChannel = _tmapModel.getChannelByName(sameChannel);
- if (inSameChannel != null) {
- TraceManager.addDev("inSameChannel != null");
- HwMemory memoryOfSameChannel = _tmapModel.getMemoryOfChannel(inSameChannel);
- if (memoryOfSameChannel != null) {
- _tmapModel.addCommToHwCommNode(channelToMap, memoryOfSameChannel);
- TraceManager.addDev("memoryOfSameChannel != null");
- }
- for (HwCommunicationNode mappedNode : _tmapModel.getAllCommunicationNodesOfChannel(inSameChannel)) {
- if (mappedNode instanceof HwBus) {
- TraceManager.addDev("mappedNode instanceof HwBus");
- _tmapModel.addCommToHwCommNode(channelToMap, mappedNode);
- }
- }
+ for (MappingPatternChannel channelMapping : _channelMapping) {
+ String channelToMapName = channelMapping.getChannelToMapName();
+ String taskOfChannelToMap = channelMapping.getTaskOfChannelToMap();
+ /*if (renamedChannels.containsKey(channelToMapName)) {
+ channelToMapName = renamedChannels.get(channelToMapName);
+ }*/
+ String channelToMapNameInModel = channelToMapName;
+ if (channelMapping.getOrigin() == MappingPatternChannel.ORIGIN_CLONE && channelsClonedIntoModel.containsKey(Map.entry(taskOfChannelToMap, channelToMapName))) {
+ channelToMapNameInModel = channelsClonedIntoModel.get(Map.entry(taskOfChannelToMap, channelToMapName));
+ } else if (channelMapping.getOrigin() == MappingPatternChannel.ORIGIN_PATTERN && channelsOfPatternIntoModel.containsKey(Map.entry(taskOfChannelToMap, channelToMapName))) {
+ channelToMapNameInModel = channelsOfPatternIntoModel.get(Map.entry(taskOfChannelToMap, channelToMapName));
+ }
+ TMLChannel channelToMap = _tmapModel.getChannelByName(channelToMapNameInModel);
+ if (channelToMap != null) {
+ TraceManager.addDev("channelToMap != null");
+ if (channelMapping.getChannelInSameMemAs() != null) {
+ String sameChannel = channelMapping.getChannelInSameMemAs();
+ String sameChannelTask = channelMapping.getTaskOfChannelInSameMem();
+ String sameChannelInModel = sameChannel;
+ if (channelMapping.getSameMemAsOrigin() == MappingPatternChannel.ORIGIN_CLONE && channelsClonedIntoModel.containsKey(Map.entry(sameChannelTask, sameChannel))) {
+ sameChannelInModel = channelsClonedIntoModel.get(Map.entry(sameChannelTask, sameChannel));
+ } else if (channelMapping.getSameMemAsOrigin() == MappingPatternChannel.ORIGIN_PATTERN && channelsOfPatternIntoModel.containsKey(Map.entry(sameChannelTask, sameChannel))) {
+ sameChannelInModel = channelsOfPatternIntoModel.get(Map.entry(sameChannelTask, sameChannel));
+ }
+ TraceManager.addDev("sameChannel= " + sameChannel);
+ TMLChannel inSameChannel = _tmapModel.getChannelByName(sameChannelInModel);
+ if (inSameChannel != null) {
+ TraceManager.addDev("inSameChannel != null");
+ HwMemory memoryOfSameChannel = _tmapModel.getMemoryOfChannel(inSameChannel);
+ if (memoryOfSameChannel != null) {
+ _tmapModel.addCommToHwCommNode(channelToMap, memoryOfSameChannel);
+ TraceManager.addDev("memoryOfSameChannel != null");
+ }
+ for (HwCommunicationNode mappedNode : _tmapModel.getAllCommunicationNodesOfChannel(inSameChannel)) {
+ if (mappedNode instanceof HwBus) {
+ TraceManager.addDev("mappedNode instanceof HwBus");
+ _tmapModel.addCommToHwCommNode(channelToMap, mappedNode);
+ }
}
- } else if (modeMapping.equals(JDialogPatternHandling.NEW_MEMORY)) {
- String busName = channelMap[2];
- HwBus bus = _tmlarchModel.getHwBusByName(busName);
- if (bus != null) {
- String nameMem = "Memory_" + channelToMapName;
- HwNode node = _tmlarchModel.getHwNodeByName(nameMem);
- if (node != null) {
- int indexMem = 0;
- String nameMemWithIndex = nameMem + indexMem;
- while(_tmlarchModel.getHwNodeByName(nameMemWithIndex) != null) {
- indexMem += 1;
- nameMemWithIndex = nameMem + indexMem;
- }
- nameMem = nameMemWithIndex;
+ }
+ } else if (channelMapping.getBusNameForNewMem() != null) {
+ String busName = channelMapping.getBusNameForNewMem();
+ HwBus bus = _tmlarchModel.getHwBusByName(busName);
+ if (bus != null) {
+ String nameMem = "Memory_" + channelToMapName;
+ HwNode node = _tmlarchModel.getHwNodeByName(nameMem);
+ if (node != null) {
+ int indexMem = 0;
+ String nameMemWithIndex = nameMem + indexMem;
+ while(_tmlarchModel.getHwNodeByName(nameMemWithIndex) != null) {
+ indexMem += 1;
+ nameMemWithIndex = nameMem + indexMem;
}
- HwMemory _newMem = new HwMemory(nameMem);
- _tmapModel.addCommToHwCommNode(channelToMap, _newMem);
- _tmapModel.addCommToHwCommNode(channelToMap, bus);
- _tmlarchModel.addHwNode(_newMem);
- HwLink linkNewMemWithBus = new HwLink("link_" + _newMem.getName() + "_to_" + bus.getName());
- linkNewMemWithBus.bus = bus;
- linkNewMemWithBus.hwnode = _newMem;
- _tmlarchModel.addHwLink(linkNewMemWithBus);
- }
+ nameMem = nameMemWithIndex;
+ }
+ HwMemory _newMem = new HwMemory(nameMem);
+ _tmapModel.addCommToHwCommNode(channelToMap, _newMem);
+ _tmapModel.addCommToHwCommNode(channelToMap, bus);
+ _tmlarchModel.addHwNode(_newMem);
+ HwLink linkNewMemWithBus = new HwLink("link_" + _newMem.getName() + "_to_" + bus.getName());
+ linkNewMemWithBus.bus = bus;
+ linkNewMemWithBus.hwnode = _newMem;
+ _tmlarchModel.addHwLink(linkNewMemWithBus);
}
}
}
-
}
return _tmapModel;
}
- public TMLMapping<?> mapChannelsInArchAuto(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, Set<String> mappedTasks, Set<String> mappedChannels, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks) {
- TMLModeling<?> tmlmModel = _tmapModel.getTMLModeling();
- TMLModeling<?> tmlmPattern = _tmapPattern.getTMLModeling();
+ public TMLMapping<?> mapChannelsInArchAuto(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, List<MappingPatternTask> _mappingPatternTasks, List<MappingPatternChannel> _mappingPatternChannels, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks) {
Map<TMLChannel, TMLChannel> correspChannels = correspondenceForChannels(_tmapModel, _tmapPattern, _patternConfiguration, _patternTasks);
- Map<TMLChannel, TMLChannel> correspondenceForClonedChannels = correspondenceForClonedChannels(_tmapModel, _tmapPattern, mappedTasks, _patternConfiguration);
for (TMLChannel corresp : correspChannels.keySet()) {
TraceManager.addDev("chInPattern=" + corresp.getName() + " chInModel=" + correspChannels.get(corresp).getName());
}
-
- for (TMLChannel chToMap : channelsFromPatternToMap) {
- TraceManager.addDev("0 chToMap=" + chToMap.getName());
- if (!mappedChannels.contains(chToMap.getName())) {
- TMLChannel chInPattern = _tmapPattern.getChannelByName(chToMap.getName());
- TraceManager.addDev("chToMap=" + chToMap.getName());
- TraceManager.addDev("chInPattern=" + chInPattern.getName());
+ List<MappingPatternChannel> allChannelsToMap = MappingPatternChannel.getChannelsToMap(_patternConfiguration.getPortsConnection(), _patternTasks, _patternConfiguration.getClonedTasks());
+ List<MappingPatternChannel> channelsToMapAuto = new ArrayList<MappingPatternChannel>();
+ for (MappingPatternChannel mappingPatternChannel : allChannelsToMap) {
+ TraceManager.addDev("getTaskOfChannelToMap: " + mappingPatternChannel.getTaskOfChannelToMap() + " getChannelToMapName: " + mappingPatternChannel.getChannelToMapName() + " getOrigin: " + mappingPatternChannel.getOrigin());
+ boolean isMapped = false;
+ for (MappingPatternChannel mappedPatternChannel : _mappingPatternChannels) {
+ if (mappingPatternChannel.getChannelToMapName().equals(mappedPatternChannel.getChannelToMapName()) && mappingPatternChannel.getTaskOfChannelToMap().equals(mappedPatternChannel.getTaskOfChannelToMap())) {
+ isMapped = true;
+ break;
+ }
+ }
+ if (!isMapped) {
+ channelsToMapAuto.add(mappingPatternChannel);
+ }
+ }
+ for (MappingPatternChannel mappingPatternChannel : channelsToMapAuto) {
+ String chToMapName = mappingPatternChannel.getChannelToMapName();
+ String taskOfChToMapName = mappingPatternChannel.getTaskOfChannelToMap();
+ TMLChannel chToMap = null;
+ TMLChannel chInPattern = null;
+ TraceManager.addDev("chToMapName: " + chToMapName + " taskOfChToMapName: " + taskOfChToMapName);
+ if (mappingPatternChannel.getOrigin() == MappingPatternChannel.ORIGIN_CLONE) {
+ String chToMapNameInModel = channelsClonedIntoModel.get(Map.entry(taskOfChToMapName, chToMapName));
+ chToMap = _tmapModel.getChannelByName(chToMapNameInModel);
+ TraceManager.addDev("ORIGIN_CLONE: chToMap=" + chToMap.getName());
+ chInPattern = getKeyByValue(correspChannels, chToMap);
+ TraceManager.addDev("ORIGIN_CLONE: chInPattern=" + chInPattern.getName());
+ } else if (mappingPatternChannel.getOrigin() == MappingPatternChannel.ORIGIN_PATTERN) {
+ chInPattern = _tmapPattern.getChannelByName(chToMapName);
+ chToMap = _tmapModel.getChannelByName(channelsOfPatternIntoModel.get(Map.entry(taskOfChToMapName, chToMapName)));
+ TraceManager.addDev("ORIGIN_PATTERN: chInPattern=" + chInPattern.getName());
+ TraceManager.addDev("ORIGIN_PATTERN: chToMap=" + chToMap.getName());
+ }
+ if (chToMap != null && chInPattern != null) {
ArrayList<HwCommunicationNode> hwComsOfChannel = _tmapPattern.getAllCommunicationNodesOfChannel(chInPattern);
TraceManager.addDev("hwComsOfChannel size=" + hwComsOfChannel.size());
Boolean chIsMappedToMem = false;
Boolean chIsMappedToBuses = false;
for (HwCommunicationNode hwComOfChannel : hwComsOfChannel) {
- TraceManager.addDev("hwComOfChannel=" + hwComOfChannel.getName());
if (hwComOfChannel instanceof HwMemory) {
if (!chIsMappedToMem) {
HashSet<TMLElement> channelsInThisHwCom = _tmapPattern.getLisMappedChannels(hwComOfChannel);
for (TMLElement elemInHwCom : channelsInThisHwCom) {
if (elemInHwCom instanceof TMLChannel) {
TMLChannel channelInHwCom = (TMLChannel) elemInHwCom;
- TraceManager.addDev("Mem channelInHwCom=" + channelInHwCom.getName());
- if (correspChannels.containsKey(channelInHwCom)) {
- TMLChannel channelInModel = tmlmModel.getChannelByName((correspChannels.get(channelInHwCom)).getName());
+ if (channelInHwCom != chInPattern && correspChannels.containsKey(channelInHwCom)) {
+ TMLChannel channelInModel = correspChannels.get(channelInHwCom);
ArrayList<HwCommunicationNode> hwsMapChannelInModel = _tmapModel.getAllCommunicationNodesOfChannel(channelInModel);
if (hwsMapChannelInModel.size() > 0) {
for (HwCommunicationNode hwMapChannelInModel : hwsMapChannelInModel) {
@@ -1733,38 +1709,29 @@ public class PatternIntegration implements Runnable {
}
}
}
- TraceManager.addDev("hwComsOfChannel ELEM MEM");
} else {
if (!chIsMappedToBuses) {
HashSet<TMLElement> channelsInThisHwCom = _tmapPattern.getLisMappedChannels(hwComOfChannel);
for (TMLElement elemInHwCom : channelsInThisHwCom) {
if (elemInHwCom instanceof TMLChannel) {
TMLChannel channelInHwCom = (TMLChannel) elemInHwCom;
- TraceManager.addDev("Bus channelInHwCom=" + channelInHwCom.getName());
- if (correspChannels.containsKey(channelInHwCom)) {
- TMLChannel channelInModel = tmlmModel.getChannelByName((correspChannels.get(channelInHwCom)).getName());
+ if (channelInHwCom != chInPattern && correspChannels.containsKey(channelInHwCom)) {
+ TMLChannel channelInModel = correspChannels.get(channelInHwCom);
ArrayList<HwCommunicationNode> hwsMapChannelInModel = _tmapModel.getAllCommunicationNodesOfChannel(channelInModel);
- TraceManager.addDev("Bus channelInModel=" + channelInModel.getName());
if (hwsMapChannelInModel.size() > 0) {
for (HwCommunicationNode hwMapChannelInModel : hwsMapChannelInModel) {
- TraceManager.addDev("Bus hwMapChannelInModel=" + hwMapChannelInModel.getName());
if (!(hwMapChannelInModel instanceof HwMemory) && !(_tmapModel.isCommNodeMappedOn(chToMap, hwMapChannelInModel))) {
_tmapModel.addCommToHwCommNode(chToMap, hwMapChannelInModel);
- TraceManager.addDev("Bus addCommToHwCommNode");
}
}
- break;
+ //break;
}
}
}
}
- }
-
- TraceManager.addDev("hwComsOfChannel ELEM BUS");
+ }
}
- TraceManager.addDev("hwComsOfChannel END 0 ");
}
- TraceManager.addDev("hwComsOfChannel END");
if (!chIsMappedToMem) {
HwMemory memMapChannel = _tmapPattern.getMemoryOfChannel(chInPattern);
String nameNewMem = memMapChannel.getName();
@@ -1785,6 +1752,7 @@ public class PatternIntegration implements Runnable {
for (HwLink link : _tmapModel.getArch().getHwLinks()) {
if (link.hwnode == hwOfTaskInConn) {
bus = link.bus;
+ break;
}
}
}
@@ -1795,6 +1763,7 @@ public class PatternIntegration implements Runnable {
for (HwLink link : _tmapModel.getArch().getHwLinks()) {
if (link.hwnode == hwOfTaskInConn) {
bus = link.bus;
+ break;
}
}
}
@@ -1825,110 +1794,26 @@ public class PatternIntegration implements Runnable {
}
}
}
- outerloop1:
- for (TMLChannel chToMap : channelsFromClonedToMap) {
- if (!mappedChannels.contains(chToMap.getName())) {
- TMLChannel chInPattern = correspondenceForClonedChannels.get(chToMap);
-
- ArrayList<HwCommunicationNode> hwComsOfChannel = _tmapPattern.getAllCommunicationNodesOfChannel(chInPattern);
- for (HwCommunicationNode hwComOfChannel : hwComsOfChannel) {
- HashSet<TMLElement> channelsInThisHwCom = _tmapPattern.getLisMappedChannels(hwComOfChannel);
- for (TMLElement elemInHwCom : channelsInThisHwCom) {
- if (elemInHwCom instanceof TMLChannel) {
- TMLChannel channelInHwCom = (TMLChannel) elemInHwCom;
- if (correspChannels.containsKey(channelInHwCom)) {
- TMLChannel channelInModel = tmlmModel.getChannelByName((correspChannels.get(channelInHwCom)).getName());
- ArrayList<HwCommunicationNode> hwsMapChannelInModel = _tmapModel.getAllCommunicationNodesOfChannel(channelInModel);
- if (hwsMapChannelInModel.size() > 0) {
- for (HwCommunicationNode hwMapChannelInModel : hwsMapChannelInModel) {
- _tmapModel.addCommToHwCommNode(chToMap, hwMapChannelInModel);
- }
- break outerloop1;
- }
- }
- }
- }
- }
- HwMemory memMapChannel = _tmapPattern.getMemoryOfChannel(chInPattern);
- String nameNewMem = memMapChannel.getName();
- HwCommunicationNode newMem = _tmapModel.getHwCommunicationNodeByName(nameNewMem);
- int ind = 0;
- while (newMem != null) {
- nameNewMem = memMapChannel.getName() + ind;
- newMem = _tmapModel.getHwCommunicationNodeByName(nameNewMem);
- ind += 1;
- }
- HwMemory _newMem = new HwMemory(nameNewMem);
- _tmapModel.addCommToHwCommNode(chToMap, _newMem);
- _tmapModel.getArch().addHwNode(_newMem);
- HwBus bus = null;
- TMLTask taskInConn = chToMap.getDestinationTask();
- HwExecutionNode hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
- if (hwOfTaskInConn != null) {
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.hwnode == hwOfTaskInConn) {
- bus = link.bus;
- }
- }
- }
- if (bus == null) {
- taskInConn = chToMap.getOriginTask();
- hwOfTaskInConn = _tmapModel.getHwNodeOf(taskInConn);
- if (hwOfTaskInConn != null) {
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.hwnode == hwOfTaskInConn) {
- bus = link.bus;
- }
- }
- }
- }
-
- if (bus == null) {
- int nbConnections = 0 ;
- for (HwNode busModel : _tmapModel.getArch().getBUSs()) {
- if (busModel instanceof HwBus) {
- int curNbConnections = 0 ;
- for (HwLink link : _tmapModel.getArch().getHwLinks()) {
- if (link.bus == busModel) {
- nbConnections += 1;
- }
- }
- if (curNbConnections > nbConnections) {
- bus = (HwBus) busModel;
- nbConnections = curNbConnections;
- }
- }
- }
-
- }
-
- HwLink linkNewMemWithBus = new HwLink("link_" + _newMem.getName() + "_to_" + bus.getName());
- linkNewMemWithBus.bus = bus;
- linkNewMemWithBus.hwnode = _newMem;
- _tmapModel.getArch().addHwLink(linkNewMemWithBus);
-
- }
- }
return _tmapModel;
}
// Find correspondence between Channels of the pattern model and the channels of cloned tasks of current Model
- public Map<TMLChannel, TMLChannel> correspondenceForClonedChannels(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, Set<String> mappedTasks, PatternConfiguration _patternConfiguration) {
+ /*public Map<TMLChannel, TMLChannel> correspondenceForClonedChannels(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, Set<String> mappedTasks, PatternConfiguration _patternConfiguration) {
TMLModeling<?> tmlmModel = _tmapModel.getTMLModeling();
TMLModeling<?> tmlmPattern = _tmapPattern.getTMLModeling();
- List <String> clonedTasksToMap = new ArrayList<String>();
+ List <String> clonedChannelsToMap = new ArrayList<String>();
// List <TMLTask> patternTasksToMap = new ArrayList<TMLTask>();
for (String taskName : _patternConfiguration.getClonedTasks().keySet()) {
TMLTask task = tmlmModel.getTMLTaskByName(taskName);
if (task != null && !mappedTasks.contains(taskName)) {
- clonedTasksToMap.add(task.getName());
+ clonedChannelsToMap.add(task.getName());
}
}
Map<TMLChannel, TMLChannel> correspChannels = new HashMap<TMLChannel, TMLChannel>();
for (String taskPatternName : _patternConfiguration.getPortsConnection().keySet()) {
for (String[] pc : _patternConfiguration.getPortsConnection().get(taskPatternName)) {
- if (clonedTasksToMap.contains(pc[1])) {
+ if (clonedChannelsToMap.contains(pc[1])) {
TMLChannel chInPattern = tmlmPattern.getChannelByName(pc[0]);
if (chInPattern != null) {
String nameChInModel = pc[2];
@@ -1941,33 +1826,31 @@ public class PatternIntegration implements Runnable {
}
}
return correspChannels;
- }
+ }*/
// Find correspondence between channels of the pattern model and the channels of current Model
public Map<TMLChannel, TMLChannel> correspondenceForChannels(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks) {
TMLModeling<?> tmlmModel = _tmapModel.getTMLModeling();
TMLModeling<?> tmlmPattern = _tmapPattern.getTMLModeling();
Map<TMLChannel, TMLChannel> correspChannels = new HashMap<TMLChannel, TMLChannel>();
- for (String taskPatternName : _patternConfiguration.getPortsConnection().keySet()) {
- for (String[] pc : _patternConfiguration.getPortsConnection().get(taskPatternName)) {
- TMLChannel chInPattern = tmlmPattern.getChannelByName(pc[0]);
- if (chInPattern != null) {
- String nameChInModel = pc[2];
- if (renamedChannels.containsKey(nameChInModel)) {
- nameChInModel = renamedChannels.get(nameChInModel);
- }
- TMLChannel chInModel = tmlmModel.getChannelByName(nameChInModel);
- if (chInModel != null) {
- correspChannels.put(chInPattern, chInModel);
- }
- }
+ for (Entry<String, String> chTask : channelsOfPatternIntoModel.keySet()) {
+ TMLChannel chInPattern = tmlmPattern.getChannelByName(chTask.getValue());
+ TMLChannel chInModel = tmlmModel.getChannelByName(channelsOfPatternIntoModel.get(chTask));
+ if (chInModel != null && chInPattern != null) {
+ correspChannels.put(chInPattern, chInModel);
}
}
- for (String taskName : _patternTasks.keySet()) {
- for (PortTaskJsonFile portTask : _patternTasks.get(taskName).internalPorts) {
- TMLChannel chInPattern = tmlmPattern.getChannelByName(portTask.name);
- TMLChannel chInModel = tmlmModel.getChannelByName(portTask.name);
- if (chInPattern != null && chInModel != null) {
+ for (PatternConnection patternConnection : _patternConfiguration.getPortsConnection()) {
+ if (!patternConnection.isANewChannelRequired(_patternConfiguration.getPortsConnection(), _patternTasks, _patternConfiguration.getClonedTasks())) {
+ String chNameInModel = patternConnection.getModelChannelName();
+ String taskNameInModel = patternConnection.getModelTaskName();
+ if (channelsClonedIntoModel.containsKey(Map.entry(taskNameInModel, chNameInModel))) {
+ chNameInModel = channelsClonedIntoModel.get(Map.entry(taskNameInModel, chNameInModel));
+ }
+
+ TMLChannel chInPattern = tmlmPattern.getChannelByName(patternConnection.getPatternChannel());
+ TMLChannel chInModel = tmlmModel.getChannelByName(chNameInModel);
+ if (chInModel != null && chInPattern != null) {
correspChannels.put(chInPattern, chInModel);
}
}
@@ -1975,6 +1858,94 @@ public class PatternIntegration implements Runnable {
return correspChannels;
}
+ public TMLMapping<?> generateSecurityForChannels(TMLMapping<?> _tmapModel, TMLMapping<?> _tmapPattern, PatternConfiguration _patternConfiguration, LinkedHashMap<String, TaskPattern> _patternTasks, String _appTabName) {
+ boolean hasSecChannel = false;
+ Map<TMLChannel, TMLChannel> correspChannels = correspondenceForChannels(_tmapModel, _tmapPattern, _patternConfiguration, _patternTasks);
+ for (PatternChannelWithSecurity channelWithSec : _patternConfiguration.getChannelsWithSecurity()) {
+ TMLChannel chSec = correspChannels.get(_tmapPattern.getChannelByName(channelWithSec.getChannelName()));
+ if (chSec != null) {
+ TraceManager.addDev("channelsWithSec = " + chSec.getName());
+ if (channelWithSec.isConfidential()) {
+ TraceManager.addDev("channelsWithSec with conf ");
+ chSec.setEnsureConf(true);
+ chSec.checkConf = true;
+ }
+ if (channelWithSec.getAuthenticity() == PatternChannelWithSecurity.WEAK_AUTHENTICITY) {
+ TraceManager.addDev("channelsWithSec with weak auth ");
+ chSec.setEnsureWeakAuth(true);
+ chSec.checkAuth = true;
+ }
+ if (channelWithSec.getAuthenticity() == PatternChannelWithSecurity.STRONG_AUTHENTICITY) {
+ TraceManager.addDev("channelsWithSec with strong auth");
+ chSec.setEnsureStrongAuth(true);
+ chSec.setEnsureWeakAuth(true);
+ chSec.checkAuth = true;
+ }
+ hasSecChannel = true;
+ }
+ }
+ if (hasSecChannel) {
+ TraceManager.addDev("hasSecChannel");
+ if (_appTabName != "") {
+ TraceManager.addDev("appName=" + _appTabName);
+ for (TMLTask task : _tmapModel.getTMLModeling().getTasks()) {
+ String[] taskNameSplit = task.getName().split("__");
+ if (taskNameSplit.length == 1) {
+ task.setName(_appTabName + "__" + task.getName());
+ }
+ }
+ for (TMLChannel ch : _tmapModel.getTMLModeling().getChannels()) {
+ String[] channelNameSplit = ch.getName().split("__");
+ if (channelNameSplit.length == 1) {
+ ch.setName(_appTabName + "__" + ch.getName());
+ }
+ }
+ for (TMLEvent evt : _tmapModel.getTMLModeling().getEvents()) {
+ String[] eventNameSplit = evt.getName().split("__");
+ if (eventNameSplit.length == 1) {
+ evt.setName(_appTabName + "__" + evt.getName());
+ }
+ }
+ for (TMLRequest req : _tmapModel.getTMLModeling().getRequests()) {
+ String[] requestNameSplit = req.getName().split("__");
+ if (requestNameSplit.length == 1) {
+ req.setName(_appTabName + "__" + req.getName());
+ }
+ }
+
+ SecurityGenerationForTMAP secgen = new SecurityGenerationForTMAP(_appTabName, _tmapModel, "100", "0", "100", new HashMap<String, java.util.List<String>>());
+ _tmapModel = secgen.startThread();
+ _tmapModel = secgen.autoMapKeys();
+ for (TMLTask task : _tmapModel.getTMLModeling().getTasks()) {
+ String[] taskNameSplit = task.getName().split("__");
+ task.setName(taskNameSplit[taskNameSplit.length-1]);
+ }
+ for (TMLChannel ch : _tmapModel.getTMLModeling().getChannels()) {
+ String[] channelNameSplit = ch.getName().split("__");
+ ch.setName(channelNameSplit[channelNameSplit.length-1]);
+ }
+ for (TMLEvent evt : _tmapModel.getTMLModeling().getEvents()) {
+ String[] eventNameSplit = evt.getName().split("__");
+ evt.setName(eventNameSplit[eventNameSplit.length-1]);
+ }
+ for (TMLRequest req : _tmapModel.getTMLModeling().getRequests()) {
+ String[] requestNameSplit = req.getName().split("__");
+ req.setName(requestNameSplit[requestNameSplit.length-1]);
+ }
+ }
+ }
+ return _tmapModel;
+ }
+
+ public static <T, E> T getKeyByValue(Map<T, E> map, E value) {
+ for (Entry<T, E> entry : map.entrySet()) {
+ if (Objects.equals(value, entry.getValue())) {
+ return entry.getKey();
+ }
+ }
+ return null;
+ }
+
@SuppressWarnings("unchecked")
public TMLMapping<?> getTMLMappingOfPattern(String _path, String fileName) {
TMLMappingTextSpecification<Class<?>> tmts = new TMLMappingTextSpecification<Class<?>>(fileName);
diff --git a/src/main/java/tmltranslator/patternhandling/PatternPortsConfig.java b/src/main/java/tmltranslator/patternhandling/PatternPortsConfig.java
index 217e90fae2a4c0de6ca81f959e25bd175df827dc..ccea9e5d7e20edc9590c51854473bcd4829de6e0 100644
--- a/src/main/java/tmltranslator/patternhandling/PatternPortsConfig.java
+++ b/src/main/java/tmltranslator/patternhandling/PatternPortsConfig.java
@@ -1,6 +1,6 @@
package tmltranslator.patternhandling;
/**
- * Class MappingPatternTask
+ * Class PatternPortsConfig
*
* Creation: 25/10/2023
*
@@ -8,21 +8,26 @@ package tmltranslator.patternhandling;
* @version 1.0 25/10/2023
*/
-import myutil.TraceManager;
+import java.util.ArrayList;
+import java.util.LinkedHashMap;
+import java.util.List;
+
import tmltranslator.*;
public class PatternPortsConfig {
+ public final static String REMOVE_PORT_OPTION = " Remove";
+ public final static String MERGE_PORT_OPTION = " Merge with ";
+ public final static String TASK_CHANNEL_SEPARATOR = "::";
+
String taskOfChannelToConfig;
String channelToConfig;
Boolean isChannelToRemove;
String mergeWith;
- public PatternPortsConfig(String taskOfChannelToConfig, String channelToConfig, Boolean isChannelToRemove, String mergeWith) {
+ public PatternPortsConfig(String taskOfChannelToConfig, String channelToConfig) {
this.taskOfChannelToConfig = taskOfChannelToConfig;
this.channelToConfig = channelToConfig;
- this.isChannelToRemove = isChannelToRemove;
- this.mergeWith = mergeWith;
}
public String getTaskOfChannelToConfig() {
@@ -52,10 +57,108 @@ public class PatternPortsConfig {
public void setIsChannelToRemove(Boolean _isChannelToRemove) {
isChannelToRemove = _isChannelToRemove;
+ mergeWith = null;
}
public void setMergeWith(String _mergeWith) {
mergeWith = _mergeWith;
+ isChannelToRemove = false;
}
+ public String getStringDisplay() {
+ if (isChannelToRemove) {
+ return (taskOfChannelToConfig + TASK_CHANNEL_SEPARATOR + channelToConfig + REMOVE_PORT_OPTION);
+ } else {
+ return (taskOfChannelToConfig + TASK_CHANNEL_SEPARATOR + channelToConfig + MERGE_PORT_OPTION + mergeWith);
+ }
+ }
+
+ public String getTaskChannelToConfig() {
+ return (taskOfChannelToConfig + TASK_CHANNEL_SEPARATOR + channelToConfig);
+ }
+
+ public static String[] seperateTaskAndChannel(String st) {
+ String[] split = st.split(TASK_CHANNEL_SEPARATOR);
+ String task, channel;
+ if (split.length == 2) {
+ task = split[0];
+ channel = split[1];
+ return new String[]{task, channel};
+ } else {
+ return null;
+ }
+ }
+
+ public static List<PatternPortsConfig> getPortsToConfig(LinkedHashMap<String, TaskPorts> _portsTaskOfModelAll, LinkedHashMap<String, TaskPorts> _portsTaskOfModelLeft, List<String> clonedTasks, TMLModeling<?> tmlmodel) {
+ List<PatternPortsConfig> portsToConf = new ArrayList<PatternPortsConfig>();
+ for (String task : _portsTaskOfModelLeft.keySet()) {
+ if (!clonedTasks.contains(task)) {
+ TMLTask tmlTask = tmlmodel.getTMLTaskByName(task);
+ TaskPorts pt = _portsTaskOfModelLeft.get(task);
+ if (tmlTask != null) {
+ for (String wc : pt.getWriteChannels()) {
+ for (int i = 0; i < tmlTask.getWriteChannels().size() ; i++) {
+ if (tmlTask.getWriteChannels().get(i).getChannel(0).getName().equals(wc)) {
+ for (String taskAll : _portsTaskOfModelAll.keySet()) {
+ if (!clonedTasks.contains(taskAll) && _portsTaskOfModelAll.get(taskAll).getReadChannels().contains(wc) && !_portsTaskOfModelLeft.get(taskAll).getReadChannels().contains(wc)) {
+ PatternPortsConfig patternPortsConfig = new PatternPortsConfig(task, wc);
+ if (!portsToConf.contains(patternPortsConfig)) {
+ portsToConf.add(patternPortsConfig);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ for (String rc : pt.getReadChannels()) {
+ for (int i = 0; i < tmlTask.getReadChannels().size() ; i++) {
+ if (tmlTask.getReadChannels().get(i).getChannel(0).getName().equals(rc)) {
+ for (String taskAll : _portsTaskOfModelAll.keySet()) {
+ if (!clonedTasks.contains(taskAll) && _portsTaskOfModelAll.get(taskAll).getWriteChannels().contains(rc) && !_portsTaskOfModelLeft.get(taskAll).getWriteChannels().contains(rc)) {
+ PatternPortsConfig patternPortsConfig = new PatternPortsConfig(task, rc);
+ if (!portsToConf.contains(patternPortsConfig)) {
+ portsToConf.add(patternPortsConfig);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ for (String se : pt.getSendEvents()) {
+ for (int i = 0; i < tmlTask.getSendEvents().size() ; i++) {
+ if (tmlTask.getSendEvents().get(i).getEvent().getName().equals(se)) {
+ for (String taskAll : _portsTaskOfModelAll.keySet()) {
+ if (!clonedTasks.contains(taskAll) && _portsTaskOfModelAll.get(taskAll).getWaitEvents().contains(se) && !_portsTaskOfModelLeft.get(taskAll).getWaitEvents().contains(se)) {
+ PatternPortsConfig patternPortsConfig = new PatternPortsConfig(task, se);
+ if (!portsToConf.contains(patternPortsConfig)) {
+ portsToConf.add(patternPortsConfig);
+ }
+ }
+ }
+ }
+ }
+ }
+ for (String we : pt.getWaitEvents()) {
+ for (int i = 0; i < tmlTask.getWaitEvents().size() ; i++) {
+ if (tmlTask.getWaitEvents().get(i).getEvent().getName().equals(we)) {
+ for (String taskAll : _portsTaskOfModelAll.keySet()) {
+ if (!clonedTasks.contains(taskAll) && _portsTaskOfModelAll.get(taskAll).getSendEvents().contains(we) && !_portsTaskOfModelLeft.get(taskAll).getSendEvents().contains(we)) {
+ PatternPortsConfig patternPortsConfig = new PatternPortsConfig(task, we);
+ if (!portsToConf.contains(patternPortsConfig)) {
+ portsToConf.add(patternPortsConfig);
+ }
+ }
+ }
+ }
+ }
+ }
+
+ }
+ }
+ }
+
+ return portsToConf;
+ }
}
diff --git a/src/main/java/tmltranslator/patternhandling/PortTaskJsonFile.java b/src/main/java/tmltranslator/patternhandling/PortTaskJsonFile.java
index 8c90067a0bdef068e38270fb1d0449c6ba030a7e..8d64f29253c1b56d45ec64a587ce1c91e48674ac 100644
--- a/src/main/java/tmltranslator/patternhandling/PortTaskJsonFile.java
+++ b/src/main/java/tmltranslator/patternhandling/PortTaskJsonFile.java
@@ -8,7 +8,6 @@ package tmltranslator.patternhandling;
* @version 1.0 28/08/2023
*/
-import myutil.TraceManager;
import tmltranslator.*;
diff --git a/src/main/java/tmltranslator/patternhandling/SecurityGenerationForTMAP.java b/src/main/java/tmltranslator/patternhandling/SecurityGenerationForTMAP.java
index 04f0cbaa9d51f2de6f501f4397a5b30df2090bf1..bc792153bc3cd74c7029fe01b34916548bd3dc76 100644
--- a/src/main/java/tmltranslator/patternhandling/SecurityGenerationForTMAP.java
+++ b/src/main/java/tmltranslator/patternhandling/SecurityGenerationForTMAP.java
@@ -18,8 +18,6 @@ import ui.TGComponent;
import java.io.Reader;
import java.util.*;
-import org.apache.batik.anim.timing.Trace;
-
public class SecurityGenerationForTMAP implements Runnable {
String appName;
diff --git a/src/main/java/tmltranslator/patternhandling/TaskPorts.java b/src/main/java/tmltranslator/patternhandling/TaskPorts.java
index 969599977146b2b409a6f02e45c17f2178ad8c55..b08ced5c06ce10d6a3fbd48968a914273d8be73b 100644
--- a/src/main/java/tmltranslator/patternhandling/TaskPorts.java
+++ b/src/main/java/tmltranslator/patternhandling/TaskPorts.java
@@ -8,17 +8,10 @@ package tmltranslator.patternhandling;
* @version 1.0 07/09/2023
*/
-import myutil.TraceManager;
import tmltranslator.*;
-import java.io.IOException;
-import java.nio.charset.Charset;
-import java.nio.file.Files;
-import java.nio.file.Path;
import java.util.*;
-import org.json.JSONArray;
-
public class TaskPorts {
List<String> writeChannels = new ArrayList<String>();
List<String> readChannels = new ArrayList<String>();
diff --git a/src/main/java/ui/GTURTLEModeling.java b/src/main/java/ui/GTURTLEModeling.java
index 4d8f67e42a074f65b3210095e113692e673c6aa6..d7d38824aa92c82354b4539618021c9ac0e200b6 100644
--- a/src/main/java/ui/GTURTLEModeling.java
+++ b/src/main/java/ui/GTURTLEModeling.java
@@ -76,7 +76,6 @@ import tmltranslator.patternhandling.PatternConfig2Json;
import tmltranslator.patternhandling.PatternConfiguration;
import tmltranslator.patternhandling.PatternCreation;
import tmltranslator.patternhandling.PatternIntegration;
-import tmltranslator.patternhandling.PortTaskJsonFile;
import tmltranslator.patternhandling.SecurityGenerationForTMAP;
import tmltranslator.patternhandling.TMRGeneration;
import tmltranslator.patternhandling.TaskPattern;
@@ -1637,7 +1636,7 @@ public class GTURTLEModeling {
}
@SuppressWarnings("unchecked")
- public void createPattern(MainGUI gui, List<String> selectedTasks, String patternName, String patternsPath) {
+ public void createPattern(List<String> selectedTasks, String patternName, String patternsPath) {
PatternCreation pattern = new PatternCreation(selectedTasks, patternName, patternsPath, tmap);
pattern.startThread();
}
@@ -1659,111 +1658,6 @@ public class GTURTLEModeling {
LinkedHashMap<String, TaskPattern> patternTasks = TaskPattern.parsePatternJsonFile(patternPath, patternName+".json");
PatternIntegration patternInteg = new PatternIntegration(patternPath, patternName, patternConfiguration, patternTasks, tmap);
tmap = (TMLMapping<TGComponent>) patternInteg.startThread();
-
- LinkedHashMap<String, List<PortTaskJsonFile>> channelsWithSec = patternConfiguration.getChannelsWithSecurity();
- boolean hasSecChannel = false;
- for (String taskOfChannelWithSec : channelsWithSec.keySet()) {
- for (PortTaskJsonFile portTask : channelsWithSec.get(taskOfChannelWithSec)) {
- TMLChannel chSec = tmap.getChannelByName(portTask.getName());
- for (TMLChannel chann : tmap.getTMLModeling().getChannels()) {
- TraceManager.addDev("chann= " + chann.getName());
- }
- TraceManager.addDev("portTask = " + portTask.getName());
- if (chSec != null) {
- TraceManager.addDev("channelsWithSec = " + chSec.getName());
- if (portTask.getConfidentiality().toUpperCase().equals(PatternCreation.WITH_CONFIDENTIALITY.toUpperCase())) {
- TraceManager.addDev("channelsWithSec with conf ");
- chSec.setEnsureConf(true);
- chSec.checkConf = true;
- }
- if (portTask.getAuthenticity().toUpperCase().equals(PatternCreation.WEAK_AUTHENTICITY.toUpperCase())) {
- TraceManager.addDev("channelsWithSec with weak auth ");
- chSec.setEnsureWeakAuth(true);
- chSec.checkAuth = true;
- }
- if (portTask.getAuthenticity().toUpperCase().equals(PatternCreation.STRONG_AUTHENTICITY.toUpperCase())) {
- TraceManager.addDev("channelsWithSec with strong auth");
- chSec.setEnsureStrongAuth(true);
- chSec.setEnsureWeakAuth(true);
- chSec.checkAuth = true;
- }
-
- //tmap = autoSecure(gui, "", tmap, arch, "100", "0", "100", confToCheck, authWeakToCheck, authStrongToCheck, new HashMap<String, java.util.List<String>>());
-
-
- //GTMLModeling gtm = new GTMLModeling(newarch, true);
- //tmap = gtm.translateToTMLMapping(true, true);
- //listE = gtm.getCorrespondanceTable();
- /*TMLModeling<?> tmlmNew = tmap.getTMLModeling();
- for (TMLTask task : tmlmNew.getTasks()) {
- String[] taskNameSplit = task.getName().split("__");
- task.setName(taskNameSplit[taskNameSplit.length-1]);
- }
- for (TMLChannel ch : tmlmNew.getChannels()) {
- String[] channelNameSplit = ch.getName().split("__");
- ch.setName(channelNameSplit[channelNameSplit.length-1]);
- }
- for (TMLEvent evt : tmlmNew.getEvents()) {
- String[] eventNameSplit = evt.getName().split("__");
- evt.setName(eventNameSplit[eventNameSplit.length-1]);
- }
- for (TMLRequest req : tmlmNew.getRequests()) {
- String[] requestNameSplit = req.getName().split("__");
- req.setName(requestNameSplit[requestNameSplit.length-1]);
- }*/
- hasSecChannel = true;
- }
- }
- }
- if (hasSecChannel) {
- TraceManager.addDev("hasSecChannel");
- if (appTabName != "") {
- TraceManager.addDev("appName="+appTabName);
- for (TMLTask task : tmap.getTMLModeling().getTasks()) {
- String[] taskNameSplit = task.getName().split("__");
- if (taskNameSplit.length == 1) {
- task.setName(appTabName + "__" + task.getName());
- }
- }
- for (TMLChannel ch : tmap.getTMLModeling().getChannels()) {
- String[] channelNameSplit = ch.getName().split("__");
- if (channelNameSplit.length == 1) {
- ch.setName(appTabName + "__" + ch.getName());
- }
- }
- for (TMLEvent evt : tmap.getTMLModeling().getEvents()) {
- String[] eventNameSplit = evt.getName().split("__");
- if (eventNameSplit.length == 1) {
- evt.setName(appTabName + "__" + evt.getName());
- }
- }
- for (TMLRequest req : tmap.getTMLModeling().getRequests()) {
- String[] requestNameSplit = req.getName().split("__");
- if (requestNameSplit.length == 1) {
- req.setName(appTabName + "__" + req.getName());
- }
- }
- }
- SecurityGenerationForTMAP secgen = new SecurityGenerationForTMAP(appTabName, tmap, "100", "0", "100", new HashMap<String, java.util.List<String>>());
- tmap = (TMLMapping<TGComponent>) secgen.startThread();
- tmap = (TMLMapping<TGComponent>) secgen.autoMapKeys();
- for (TMLTask task : tmap.getTMLModeling().getTasks()) {
- String[] taskNameSplit = task.getName().split("__");
- task.setName(taskNameSplit[taskNameSplit.length-1]);
- }
- for (TMLChannel ch : tmap.getTMLModeling().getChannels()) {
- String[] channelNameSplit = ch.getName().split("__");
- ch.setName(channelNameSplit[channelNameSplit.length-1]);
- }
- for (TMLEvent evt : tmap.getTMLModeling().getEvents()) {
- String[] eventNameSplit = evt.getName().split("__");
- evt.setName(eventNameSplit[eventNameSplit.length-1]);
- }
- for (TMLRequest req : tmap.getTMLModeling().getRequests()) {
- String[] requestNameSplit = req.getName().split("__");
- req.setName(requestNameSplit[requestNameSplit.length-1]);
- }
- }
try {
String archTabName = ((CorrespondanceTGElement)(tmap.getCorrespondanceList())).getTG(tmap.getArch().getFirstCPU()).getTDiagramPanel().tp.getNameOfTab();
gui.drawTMLAndTMAPSpecification(tmap, appTabName + "_" + patternName, archTabName + "_" + patternName);
diff --git a/src/main/java/ui/window/JDialogPatternHandling.java b/src/main/java/ui/window/JDialogPatternHandling.java
index a3e404e97f71ebbc27a27ebfbfa77877401a0e4e..4afedfce7b40e4b746d2f135269776c9758d4a73 100644
--- a/src/main/java/ui/window/JDialogPatternHandling.java
+++ b/src/main/java/ui/window/JDialogPatternHandling.java
@@ -123,8 +123,14 @@ import tmltranslator.TMLTask;
import tmltranslator.TMLWaitEvent;
import tmltranslator.TMLWriteChannel;
import tmltranslator.patternhandling.AttributeTaskJsonFile;
+import tmltranslator.patternhandling.MappingPatternChannel;
+import tmltranslator.patternhandling.MappingPatternTask;
+import tmltranslator.patternhandling.PatternChannelWithSecurity;
+import tmltranslator.patternhandling.PatternCloneTask;
import tmltranslator.patternhandling.PatternConfiguration;
+import tmltranslator.patternhandling.PatternConnection;
import tmltranslator.patternhandling.PatternCreation;
+import tmltranslator.patternhandling.PatternPortsConfig;
import tmltranslator.patternhandling.PortTaskJsonFile;
import tmltranslator.patternhandling.TaskPattern;
import tmltranslator.patternhandling.TaskPorts;
@@ -153,22 +159,6 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
protected final static int NOT_STARTED = 1;
protected final static int STARTED = 2;
protected final static int STOPPED = 3;
-
- public final static String CLONE_TASK_SEPARATOR = " clone of ";
- public final static String TASK_CHANNEL_SEPARATOR = "::";
- public final static String PORT_CONNECTION_SEPARATOR = " <-> ";
- public final static String NEW_PORT_OPTION = " New port";
- public final static String REMOVE_PORT_OPTION = "Remove";
- public final static String MERGE_PORT_OPTION = "Merge with ";
- public final static String PORT_CONFIGURATION_SEPARATOR = " ";
- public final static String MAP_TASK_IN_SAME_HW_SEPARATOR = " mapped in the same HW as ";
- public final static String MAP_TASK_IN_NEW_HW_SEPARATOR = " mapped in a new HW linked to ";
- public final static String SAME_HW = "SAME";
- public final static String NEW_HW = "NEW";
- public final static String MAP_CHANNEL_IN_SAME_MEMORY_SEPARATOR = " mapped in the same Memory as ";
- public final static String MAP_CHANNEL_IN_NEW_MEMORY_SEPARATOR = " mapped in a new memory linked to ";
- public final static String SAME_MEMORY = "SAME";
- public final static String NEW_MEMORY = "NEW";
String pathPatterns;
TURTLEPanel currPanel;
@@ -207,7 +197,7 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
JComboBox<String> jComboBoxAddAuthenticity;
JList<String> jListConnectedPorts;
Vector<String> connectedPorts = new Vector<String>();
- Vector<String> connectedPortsFull = new Vector<String>();
+ List<PatternConnection> patternConnectionList = new ArrayList<PatternConnection>();
JButton addConnectionBetweenSelectedPorts, removeConnectionBetweenPorts;
//JPanel jPanelPatternIntegration;
JButton buttonCloneTask, buttonAddPortInTask;
@@ -221,6 +211,7 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
JComboBox<String> jComboBoxPortsConfigMerge;
JList<String> jListConfigPorts;
Vector<String> configuredPorts = new Vector<String>();
+ List<PatternPortsConfig> configuredPortsList = new ArrayList<PatternPortsConfig>();
JButton addConfigPorts, removeConfigPorts;
JButton buttonTasksMapInArch;
JButton buttonChannelsMapInArch;
@@ -234,12 +225,14 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
JButton addClonedTask, removeClonedTask;
JList<String> jListClonedTasks;
Vector<String> clonedTasks = new Vector<String>();
- Vector<String> clonedTasksName = new Vector<String>();
+ List<PatternCloneTask> clonedTasksList = new ArrayList<PatternCloneTask>();
ButtonGroup mapTaskGroup;
JRadioButton jRadioMapTaskInExistingHw, jRadioMapTaskInNewHw;
Vector<String> tasksToMap = new Vector<String>();
+ List<MappingPatternTask> tasksToMapList = new ArrayList<MappingPatternTask>();
Vector<String> tasksToMapInSameHw = new Vector<String>();
+ List<MappingPatternTask> tasksToMapInSameHwList = new ArrayList<MappingPatternTask>();
Vector<String> busToLinkNewHw = new Vector<String>();
DefaultComboBoxModel<String> modelTaskToMap = new DefaultComboBoxModel<>(tasksToMap);
DefaultComboBoxModel<String> modelMapTaskInSameHwAs = new DefaultComboBoxModel<>(tasksToMapInSameHw);
@@ -247,11 +240,14 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
JButton addMappedTask, removeMappedTask;
JList<String> jListMappedTasks;
Vector<String> mappedTasks = new Vector<String>();
+ List<MappingPatternTask> mappedTasksList = new ArrayList<MappingPatternTask>();
ButtonGroup mapChannelGroup;
JRadioButton jRadioMapChannelInExistingMem, jRadioMapChannelInNewMem;
Vector<String> channelsToMap = new Vector<String>();
+ List<MappingPatternChannel> channelsToMapList = new ArrayList<MappingPatternChannel>();
Vector<String> channelsToMapInSameMem = new Vector<String>();
+ List<MappingPatternChannel> channelsToMapInSameMemList = new ArrayList<MappingPatternChannel>();
Vector<String> busToLinkNewMem = new Vector<String>();
DefaultComboBoxModel<String> modelChannelToMap = new DefaultComboBoxModel<>(channelsToMap);
DefaultComboBoxModel<String> modelMapChannelInSameMemAs = new DefaultComboBoxModel<>(channelsToMapInSameMem);
@@ -259,6 +255,7 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
JButton addMappedChannel, removeMappedChannel;
JList<String> jListMappedChannels;
Vector<String> mappedChannels = new Vector<String>();
+ List<MappingPatternChannel> mappedChannelsList = new ArrayList<MappingPatternChannel>();
Vector<String> tasksToUpdateAttributes = new Vector<String>();
DefaultComboBoxModel<String> modelTasksToUpdateAttributes = new DefaultComboBoxModel<>(tasksToUpdateAttributes);
@@ -278,9 +275,9 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
LinkedHashMap<String, TaskPattern> patternTasksNotConnected = new LinkedHashMap<String, TaskPattern>();
LinkedHashMap<String, TaskPorts> portsTaskOfModelAll = new LinkedHashMap<String, TaskPorts>();
LinkedHashMap<String, TaskPorts> portsTaskOfModelLeft = new LinkedHashMap<String, TaskPorts>();
- LinkedHashMap<String, TaskPorts> portsTaskConfig = new LinkedHashMap<String, TaskPorts>();
+ List<PatternPortsConfig> portsTaskConfig = new ArrayList<PatternPortsConfig>();
LinkedHashMap<String, List<AttributeTaskJsonFile>> updatedPatternAttributes = new LinkedHashMap<String, List<AttributeTaskJsonFile>>();
- LinkedHashMap<String, List<PortTaskJsonFile>> channelsWithSecurity = new LinkedHashMap<String, List<PortTaskJsonFile>>();
+ List<PatternChannelWithSecurity> channelsWithSecurity = new ArrayList<PatternChannelWithSecurity>();
List<String> busesOfModel = new ArrayList<String>();
@@ -363,30 +360,6 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
return listBusName;
}
- Vector<String> getListChannelsBetweenTwoTasks(String originTaskName, String destinationTaskName) {
- Vector<String> channels = new Vector<String>();
- if (mgui.gtm.getTMLMapping().getTaskByName(originTaskName) != null && mgui.gtm.getTMLMapping().getTaskByName(destinationTaskName) != null) {
- if (mgui.gtm.getTMLMapping().getTaskByName(originTaskName).getWriteChannels().size() > 0) {
- for (int i=0; i < mgui.gtm.getTMLMapping().getTaskByName(destinationTaskName).getReadChannels().size(); i++) {
- for (int j=0 ; j < mgui.gtm.getTMLMapping().getTaskByName(destinationTaskName).getReadChannels().get(i).getNbOfChannels(); j++) {
- for (int k=0; k < mgui.gtm.getTMLMapping().getTaskByName(originTaskName).getWriteChannels().size(); k++) {
- for (int l=0; l < mgui.gtm.getTMLMapping().getTaskByName(originTaskName).getWriteChannels().get(k).getNbOfChannels(); l++) {
- if (mgui.gtm.getTMLMapping().getTaskByName(originTaskName).getWriteChannels().get(k).getChannel(l) == mgui.gtm.getTMLMapping().getTaskByName(destinationTaskName).getReadChannels().get(i).getChannel(j)) {
- String channelLongName = mgui.gtm.getTMLMapping().getTaskByName(destinationTaskName).getReadChannels().get(i).getChannel(j).getName();
- String channelShortName = channelLongName.split("__")[channelLongName.split("__").length - 1];
- if (!channels.contains(channelShortName)) {
- channels.add(channelShortName);
- }
- }
- }
- }
- }
- }
- }
- }
- return channels;
- }
-
Vector<String> getFoldersName(String path) {
Vector<String> folders = new Vector<String>();
File directoryPath = new File(path);
@@ -1394,10 +1367,11 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
String patternTaskPortName = jComboBoxPatternExternalPortOfATask.getSelectedItem().toString();
String modelTaskName = jComboBoxModelsTask.getSelectedItem().toString();
String modelTaskPortName = jComboBoxModelsPortOfTask.getSelectedItem().toString();
-
- if (!jCheckBoxConnectToNewPort.isSelected()) {
- connectedPorts.add(patternTaskName+TASK_CHANNEL_SEPARATOR+patternTaskPortName+PORT_CONNECTION_SEPARATOR+modelTaskName+TASK_CHANNEL_SEPARATOR+modelTaskPortName);
- connectedPortsFull.add(patternTaskName+TASK_CHANNEL_SEPARATOR+patternTaskPortName+PORT_CONNECTION_SEPARATOR+modelTaskName+TASK_CHANNEL_SEPARATOR+modelTaskPortName);
+ Boolean isNewPort = jCheckBoxConnectToNewPort.isSelected();
+ PatternConnection patternConnection = new PatternConnection(patternTaskName, patternTaskPortName, modelTaskName, modelTaskPortName, isNewPort);
+
+ connectedPorts.add(patternConnection.getStringDisplay());
+ if (!isNewPort) {
TaskPorts pt = portsTaskOfModelLeft.get(modelTaskName);
if (pt.getWriteChannels().contains(modelTaskPortName)) {
pt.getWriteChannels().remove(modelTaskPortName);
@@ -1408,9 +1382,6 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
} else if (pt.getWaitEvents().contains(modelTaskPortName)) {
pt.getWaitEvents().remove(modelTaskPortName);
}
- } else {
- connectedPorts.add(patternTaskName+TASK_CHANNEL_SEPARATOR+patternTaskPortName + PORT_CONNECTION_SEPARATOR +modelTaskName+ TASK_CHANNEL_SEPARATOR+patternTaskPortName+ NEW_PORT_OPTION);
- connectedPortsFull.add(patternTaskName+TASK_CHANNEL_SEPARATOR+patternTaskPortName + PORT_CONNECTION_SEPARATOR +modelTaskName+ TASK_CHANNEL_SEPARATOR+modelTaskPortName+ NEW_PORT_OPTION);
}
TaskPattern tp = patternTasksNotConnected.get(patternTaskName);
int indexElemToRemove = -1;
@@ -1420,8 +1391,6 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
break;
}
}
- TraceManager.addDev("indexElemToRemove="+indexElemToRemove);
- TraceManager.addDev("tp.getExternalPorts().size()="+tp.getExternalPorts().size());
if (indexElemToRemove >= 0) {
tp.getExternalPorts().remove(indexElemToRemove);
}
@@ -1448,6 +1417,8 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
}
}
}
+
+ patternConnectionList.add(patternConnection);
/*if (jCheckBoxAddConfidentiality.isSelected() || (jComboBoxAddAuthenticity.getSelectedIndex() >= 0 && !jComboBoxAddAuthenticity.getSelectedItem().toString().toUpperCase().equals(PatternCreation.WITHOUT_AUTHENTICITY.toUpperCase()))) {
if (channelsWithSecurity.containsKey(patternTaskName)) {
@@ -1504,21 +1475,13 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
private void removeConnectionBetweenPorts() {
int[] list = jListConnectedPorts.getSelectedIndices();
- Vector<String> v = new Vector<String>();
- Vector<String> vFull = new Vector<String>();
- String o, oFull;
+ List<PatternConnection> patternConnectionsToRemove = new ArrayList<PatternConnection>();
for (int i = 0; i < list.length; i++) {
- o = connectedPorts.elementAt(list[i]);
- oFull = connectedPortsFull.elementAt(list[i]);
-
- String[] splitO = o.split(TASK_CHANNEL_SEPARATOR, 2);
- String patternTaskName = splitO[0];
- String[] splitCom = splitO[1].split(PORT_CONNECTION_SEPARATOR, 2);
- String patternTaskPortName = splitCom[0];
- String[] splitComModel = splitCom[1].split(TASK_CHANNEL_SEPARATOR, 2);
- String modelTaskName = splitComModel[0];
- String[] splitComModelPort = splitComModel[1].split(NEW_PORT_OPTION, 2);
- String modelTaskPortName = splitComModelPort[0];
+ PatternConnection patternConnection = patternConnectionList.get(list[i]);
+ String patternTaskName = patternConnection.getPatternTaskName();
+ String patternTaskPortName = patternConnection.getPatternChannel();
+ String modelTaskName = patternConnection.getModelTaskName();
+ String modelTaskPortName = patternConnection.getModelChannelName();
for (String patternTask : patternTasksAll.keySet()) {
for (PortTaskJsonFile portTaskJsonFile : patternTasksAll.get(patternTask).getExternalPorts()) {
if (portTaskJsonFile.getName().equals(patternTaskPortName)) {
@@ -1540,7 +1503,7 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
}
}
}
- if (splitComModelPort.length == 1) {
+ if (!patternConnection.isNewPort()) {
TaskPorts pt = portsTaskOfModelLeft.get(modelTaskName);
TaskPorts ptAll = portsTaskOfModelAll.get(modelTaskName);
if (ptAll.getWriteChannels().contains(modelTaskPortName)) {
@@ -1553,14 +1516,12 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
pt.getWaitEvents().add(modelTaskPortName);
}
}
-
- v.addElement(o);
- vFull.addElement(oFull);
+ connectedPorts.remove(list[i]);
+ patternConnectionsToRemove.add(patternConnection);
jComboBoxPatternsTaskWithExternalPort.setSelectedIndex(-1);
jCheckBoxConnectToNewPort.setSelected(false);
}
- connectedPorts.removeAll(v);
- connectedPortsFull.removeAll(vFull);
+ patternConnectionList.removeAll(patternConnectionsToRemove);
jListConnectedPorts.setListData(connectedPorts);
setButtons();
}
@@ -1570,8 +1531,9 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
String nameNewTaskToClone = jFieldNewClonedTaskName.getText();
if (!tasksCanBeCloned.contains(nameNewTaskToClone) && !tasksOfModel.contains(nameNewTaskToClone) && !nameNewTaskToClone.contains(" ")) {
- clonedTasks.add(nameNewTaskToClone + CLONE_TASK_SEPARATOR + selectedTaskToClone);
- clonedTasksName.add(nameNewTaskToClone);
+ PatternCloneTask patternCloneTask = new PatternCloneTask(nameNewTaskToClone, selectedTaskToClone);
+ clonedTasks.add(patternCloneTask.getStringDisplay());
+ clonedTasksList.add(patternCloneTask);
List<String> wcs = new ArrayList<String>(portsTaskOfModelAll.get(selectedTaskToClone).getWriteChannels());
List<String> rcs = new ArrayList<String>(portsTaskOfModelAll.get(selectedTaskToClone).getReadChannels());
List<String> ses = new ArrayList<String>(portsTaskOfModelAll.get(selectedTaskToClone).getSendEvents());
@@ -1597,35 +1559,19 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
private void removeClonedTask() {
int[] list = jListClonedTasks.getSelectedIndices();
- Vector<String> v = new Vector<String>();
- Vector<String> vName = new Vector<String>();
- String o;
+ List<PatternCloneTask> patternCloneTasksToRemove = new ArrayList<PatternCloneTask>();
for (int i = 0; i < list.length; i++) {
- String[] splitS = clonedTasks.elementAt(list[i]).split(CLONE_TASK_SEPARATOR);
- o = splitS[0];
- v.addElement(clonedTasks.elementAt(list[i]));
- vName.addElement(clonedTasksName.elementAt(list[i]));
- portsTaskOfModelLeft.remove(o);
- portsTaskOfModelAll.remove(o);
- Vector<String> vConn = new Vector<String>();
- Vector<String> vConnFull = new Vector<String>();
- int indexC = 0;
- for (String st : connectedPorts) {
- String[] splitO = st.split(TASK_CHANNEL_SEPARATOR, 2);
- String patternTaskName = splitO[0];
- String[] splitCom = splitO[1].split(PORT_CONNECTION_SEPARATOR, 2);
- String patternTaskPortName = splitCom[0];
- String[] splitComModel = splitCom[1].split(TASK_CHANNEL_SEPARATOR, 2);
- String modelTaskName = splitComModel[0];
- String[] splitComModelPort = splitComModel[1].split(NEW_PORT_OPTION, 2);
- String modelTaskPortName = splitComModelPort[0];
-
- /*String[] splitO = st.split(" ");
- String patternTaskName = splitO[0];
- String patternTaskPortName = splitO[1];
- String modelTaskName = splitO[3];
- String modelTaskPortName = splitO[4];*/
- if (modelTaskName.equals(o)) {
+ PatternCloneTask patternCloneTask = clonedTasksList.get(list[i]);
+ patternCloneTasksToRemove.add(patternCloneTask);
+ portsTaskOfModelLeft.remove(patternCloneTask.getClonedTask());
+ portsTaskOfModelAll.remove(patternCloneTask.getClonedTask());
+ List<PatternConnection> patternConnectionsToRemove = new ArrayList<PatternConnection>();
+ for (PatternConnection pConnection : patternConnectionList) {
+ String patternTaskName = pConnection.getPatternTaskName();
+ String patternTaskPortName = pConnection.getPatternChannel();
+ String modelTaskName = pConnection.getModelTaskName();
+
+ if (modelTaskName.equals(patternCloneTask.getClonedTask())) {
for (String patternTask : patternTasksAll.keySet()) {
for (PortTaskJsonFile portTaskJsonFile : patternTasksAll.get(patternTask).getExternalPorts()) {
if (portTaskJsonFile.getName().equals(patternTaskPortName)) {
@@ -1647,18 +1593,16 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
}
}
}
- vConn.addElement(st);
- vConnFull.addElement(connectedPortsFull.get(indexC));
+ connectedPorts.remove(pConnection.getStringDisplay());
+ patternConnectionsToRemove.add(pConnection);
}
- indexC += 1;
}
- connectedPorts.removeAll(vConn);
- connectedPortsFull.removeAll(vConnFull);
+ clonedTasks.remove(list[i]);
+ patternConnectionList.removeAll(patternConnectionsToRemove);
jListConnectedPorts.setListData(connectedPorts);
}
+ clonedTasksList.removeAll(patternCloneTasksToRemove);
- clonedTasks.removeAll(v);
- clonedTasksName.removeAll(vName);
tasksOfModel.removeAllElements();
for (String pTaskName : portsTaskOfModelLeft.keySet()) {
tasksOfModel.add(pTaskName);
@@ -1667,134 +1611,17 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
setButtons();
}
- LinkedHashMap<String, TaskPorts> getPortsToConfig(LinkedHashMap<String, TaskPorts> _portsTaskOfModelAll, LinkedHashMap<String, TaskPorts> _portsTaskOfModelLeft, TMLModeling<?> tmlmodel) {
- LinkedHashMap<String, TaskPorts> portsToConf = new LinkedHashMap<String, TaskPorts>();
- for (String task : _portsTaskOfModelLeft.keySet()) {
- if (!clonedTasksName.contains(task)) {
- TraceManager.addDev("getPortsToConfig: task=" + task);
- TMLTask tmlTask = tmlmodel.getTMLTaskByName(task);
- TaskPorts pt = _portsTaskOfModelLeft.get(task);
- if (tmlTask != null) {
- for (String wc : pt.getWriteChannels()) {
- //TraceManager.addDev("getPortsToConfig: wc=" + wc);
- for (int i = 0; i < tmlTask.getWriteChannels().size() ; i++) {
- //TraceManager.addDev("getPortsToConfig: tmlTask.getWriteChannels()=" + tmlTask.getWriteChannels().get(i).getChannel(0).getName());
- if (tmlTask.getWriteChannels().get(i).getChannel(0).getName().equals(wc)) {
- for (String taskAll : _portsTaskOfModelAll.keySet()) {
- //String destPortName = tmlTask.getWriteChannels().get(i).getChannel(0).getDestinationPort().getName();
- //TraceManager.addDev("getPortsToConfig: destPortName=" + destPortName);
- if (_portsTaskOfModelAll.get(taskAll).getReadChannels().contains(wc) && !_portsTaskOfModelLeft.get(taskAll).getReadChannels().contains(wc)) {
- if (portsToConf.containsKey(task)) {
- if (!portsToConf.get(task).getWriteChannels().contains(wc)) {
- portsToConf.get(task).getWriteChannels().add(wc);
- //TraceManager.addDev("getPortsToConfig: add wc=" + wc);
- }
- } else {
- List<String> writeChannels = new ArrayList<String>(Arrays.asList(wc));
- List<String> readChannels = new ArrayList<String>();
- List<String> sendEvents = new ArrayList<String>();
- List<String> waitEvents = new ArrayList<String>();
- TaskPorts portTask = new TaskPorts(writeChannels, readChannels, sendEvents, waitEvents);
- portsToConf.put(task, portTask);
- //TraceManager.addDev("getPortsToConfig: new task add wc=" + wc);
- }
- }
- }
- }
- }
- }
-
- for (String rc : pt.getReadChannels()) {
- TraceManager.addDev("getPortsToConfig: rc=" + rc);
- for (int i = 0; i < tmlTask.getReadChannels().size() ; i++) {
- TraceManager.addDev("getPortsToConfig: tmlTask.getReadChannels()=" + tmlTask.getReadChannels().get(i).getChannel(0).getName());
- if (tmlTask.getReadChannels().get(i).getChannel(0).getName().equals(rc)) {
- for (String taskAll : _portsTaskOfModelAll.keySet()) {
- //String originPortName = tmlTask.getReadChannels().get(i).getChannel(0).getOriginPort().getName();
- //String[] sOriginPortName = originPortName.split("__");
- //TraceManager.addDev("getPortsToConfig: originPortName=" + originPortName);
- if (_portsTaskOfModelAll.get(taskAll).getWriteChannels().contains(rc) && !_portsTaskOfModelLeft.get(taskAll).getWriteChannels().contains(rc)) {
- if (portsToConf.containsKey(task)) {
- if (!portsToConf.get(task).getReadChannels().contains(rc)) {
- portsToConf.get(task).getReadChannels().add(rc);
- TraceManager.addDev("getPortsToConfig: add rc=" + rc);
- }
- } else {
- List<String> writeChannels = new ArrayList<String>();
- List<String> readChannels = new ArrayList<String>(Arrays.asList(rc));
- List<String> sendEvents = new ArrayList<String>();
- List<String> waitEvents = new ArrayList<String>();
- TaskPorts portTask = new TaskPorts(writeChannels, readChannels, sendEvents, waitEvents);
- portsToConf.put(task, portTask);
- TraceManager.addDev("getPortsToConfig: new task add rc=" + rc);
- }
- }
- }
- }
- }
- }
-
- for (String se : pt.getSendEvents()) {
- for (int i = 0; i < tmlTask.getSendEvents().size() ; i++) {
- if (tmlTask.getSendEvents().get(i).getEvent().getName().equals(se)) {
- for (String taskAll : _portsTaskOfModelAll.keySet()) {
- //String destPortName = tmlTask.getSendEvents().get(i).getEvent().getDestinationPort().getName();
- if (_portsTaskOfModelAll.get(taskAll).getWaitEvents().contains(se) && !_portsTaskOfModelLeft.get(taskAll).getWaitEvents().contains(se)) {
- if (portsToConf.containsKey(task)) {
- if (!portsToConf.get(task).getSendEvents().contains(se)) {
- portsToConf.get(task).getSendEvents().add(se);
- }
- } else {
- List<String> writeChannels = new ArrayList<String>();
- List<String> readChannels = new ArrayList<String>();
- List<String> sendEvents = new ArrayList<String>(Arrays.asList(se));
- List<String> waitEvents = new ArrayList<String>();
- TaskPorts portTask = new TaskPorts(writeChannels, readChannels, sendEvents, waitEvents);
- portsToConf.put(task, portTask);
- }
- }
- }
- }
- }
- }
- for (String we : pt.getWaitEvents()) {
- for (int i = 0; i < tmlTask.getWaitEvents().size() ; i++) {
- if (tmlTask.getWaitEvents().get(i).getEvent().getName().equals(we)) {
- for (String taskAll : _portsTaskOfModelAll.keySet()) {
- //String originPortName = tmlTask.getWaitEvents().get(i).getEvent().getOriginPort().getName();
- if (_portsTaskOfModelAll.get(taskAll).getSendEvents().contains(we) && !_portsTaskOfModelLeft.get(taskAll).getSendEvents().contains(we)) {
- if (portsToConf.containsKey(task)) {
- if (!portsToConf.get(task).getWaitEvents().contains(we)) {
- portsToConf.get(task).getWaitEvents().add(we);
- }
- } else {
- List<String> writeChannels = new ArrayList<String>();
- List<String> readChannels = new ArrayList<String>();
- List<String> sendEvents = new ArrayList<String>();
- List<String> waitEvents = new ArrayList<String>(Arrays.asList(we));
- TaskPorts portTask = new TaskPorts(writeChannels, readChannels, sendEvents, waitEvents);
- portsToConf.put(task, portTask);
- }
- }
- }
- }
- }
- }
-
- }
- }
- }
-
- return portsToConf;
- }
-
private void addConfigPorts() {
- String selectedTaskToConfig = jComboBoxPortsConfig.getSelectedItem().toString();
+ String selectedTaskToConfig = jComboBoxPortsConfig.getSelectedItem().toString();
+ String[] taskAndChannelSelected = PatternPortsConfig.seperateTaskAndChannel(selectedTaskToConfig);
+ PatternPortsConfig patternPortConfig = new PatternPortsConfig(taskAndChannelSelected[0], taskAndChannelSelected[1]);
if (jRadioPortConfigRemove.isSelected()) {
- configuredPorts.add(selectedTaskToConfig + PORT_CONFIGURATION_SEPARATOR + REMOVE_PORT_OPTION);
+ patternPortConfig.setIsChannelToRemove(true);
} else if (jRadioPortConfigMerge.isSelected()) {
- configuredPorts.add(selectedTaskToConfig + PORT_CONFIGURATION_SEPARATOR + MERGE_PORT_OPTION + jComboBoxPortsConfigMerge.getSelectedItem().toString());
+ patternPortConfig.setMergeWith(jComboBoxPortsConfigMerge.getSelectedItem().toString());
}
+ configuredPorts.add(patternPortConfig.getStringDisplay());
+ configuredPortsList.add(patternPortConfig);
portsConfig.remove(selectedTaskToConfig);
jComboBoxPortsConfig.setSelectedIndex(-1);
jListConfigPorts.setListData(configuredPorts);
@@ -1803,29 +1630,34 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
private void removeConfigPorts() {
int[] list = jListConfigPorts.getSelectedIndices();
- Vector<String> v = new Vector<String>();
- String o;
+ List<PatternPortsConfig> patternPortsConfigToRemove = new ArrayList<PatternPortsConfig>();
for (int i = 0; i < list.length; i++) {
- o = configuredPorts.elementAt(list[i]);
- String[] splitO = o.split(PORT_CONFIGURATION_SEPARATOR);
- portsConfig.add(splitO[0]);
- v.addElement(o);
+ PatternPortsConfig patternPortConfigToRemove = configuredPortsList.get(list[i]);
+ portsConfig.add(patternPortConfigToRemove.getTaskChannelToConfig());
+ configuredPorts.remove(list[i]);
+ patternPortsConfigToRemove.add(patternPortConfigToRemove);
}
- configuredPorts.removeAll(v);
+ configuredPortsList.removeAll(patternPortsConfigToRemove);
jListConfigPorts.setListData(configuredPorts);
jComboBoxPortsConfig.setSelectedIndex(-1);
setButtons();
}
private void addMappedTask() {
- String selectedTaskToMap = jComboBoxTaskToMap.getSelectedItem().toString();
+ //String selectedTaskToMap = jComboBoxTaskToMap.getSelectedItem().toString();
+ int selectedTaskToMapIndice = jComboBoxTaskToMap.getSelectedIndex();
+ MappingPatternTask mappingPatternTask = tasksToMapList.get(selectedTaskToMapIndice);
if (jRadioMapTaskInExistingHw.isSelected()) {
- mappedTasks.add(selectedTaskToMap + MAP_TASK_IN_SAME_HW_SEPARATOR + jComboBoxMapTaskInSameHwAs.getSelectedItem().toString());
+ int selectedTaskInSameHwIndice = jComboBoxMapTaskInSameHwAs.getSelectedIndex();
+ MappingPatternTask sameHwTask = tasksToMapInSameHwList.get(selectedTaskInSameHwIndice);
+ mappingPatternTask.setSameHwAs(sameHwTask.getTaskToMapName(), sameHwTask.getOrigin());
} else if (jRadioMapTaskInNewHw.isSelected()) {
- mappedTasks.add(selectedTaskToMap + MAP_TASK_IN_NEW_HW_SEPARATOR + jComboBoxMapTaskInNewHw.getSelectedItem().toString());
+ mappingPatternTask.setBusNameForNewHw(jComboBoxMapTaskInNewHw.getSelectedItem().toString());
}
- tasksToMap.remove(selectedTaskToMap);
- tasksToMapInSameHw.add(selectedTaskToMap);
+ mappedTasks.add(mappingPatternTask.getStringDisplay());
+ mappedTasksList.add(mappingPatternTask);
+ tasksToMapInSameHw.add(tasksToMap.remove(selectedTaskToMapIndice));
+ tasksToMapInSameHwList.add(tasksToMapList.remove(selectedTaskToMapIndice));
jComboBoxTaskToMap.setSelectedIndex(-1);
jListMappedTasks.setListData(mappedTasks);
setButtons();
@@ -1833,59 +1665,62 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
private void removeMappedTask() {
int[] list = jListMappedTasks.getSelectedIndices();
- Vector<String> v = new Vector<String>();
- String o;
+ List<MappingPatternTask> mappingPatternTasksToRemove = new ArrayList<MappingPatternTask>();
for (int i = 0; i < list.length; i++) {
- o = mappedTasks.elementAt(list[i]);
- String[] splitONew = o.split(MAP_TASK_IN_NEW_HW_SEPARATOR);
- String[] splitOSame = o.split(MAP_TASK_IN_SAME_HW_SEPARATOR);
- if (splitONew.length > 1) {
- tasksToMap.add(splitONew[0]);
- tasksToMapInSameHw.remove(splitONew[0]);
- } else if (splitOSame.length > 1) {
- tasksToMap.add(splitOSame[0]);
- tasksToMapInSameHw.remove(splitOSame[0]);
- }
- v.addElement(o);
+ MappingPatternTask mappingPatternTaskSelected = mappedTasksList.get(list[i]);
+ tasksToMap.add(mappingPatternTaskSelected.getTaskToMapName());
+ tasksToMapList.add(mappingPatternTaskSelected);
+ tasksToMapInSameHw.remove(mappingPatternTaskSelected.getSameHwAs());
+ tasksToMapInSameHwList.remove(mappingPatternTaskSelected);
+ mappingPatternTasksToRemove.add(mappingPatternTaskSelected);
+ mappedTasks.remove(list[i]);
}
- mappedTasks.removeAll(v);
+ mappedTasksList.removeAll(mappingPatternTasksToRemove);
jListMappedTasks.setListData(mappedTasks);
jComboBoxTaskToMap.setSelectedIndex(-1);
setButtons();
}
private void addMappedChannel() {
- String selectedChannelToMap = jComboBoxChannelToMap.getSelectedItem().toString();
- if (jRadioMapChannelInExistingMem.isSelected()) {
- mappedChannels.add(selectedChannelToMap + MAP_CHANNEL_IN_SAME_MEMORY_SEPARATOR + jComboBoxMapChannelInSameMemAs.getSelectedItem().toString());
- } else if (jRadioMapChannelInNewMem.isSelected()) {
- mappedChannels.add(selectedChannelToMap + MAP_CHANNEL_IN_NEW_MEMORY_SEPARATOR + jComboBoxMapChannelInNewMem.getSelectedItem().toString());
- }
- channelsToMap.remove(selectedChannelToMap);
- channelsToMapInSameMem.add(selectedChannelToMap);
- jComboBoxChannelToMap.setSelectedIndex(-1);
- jListMappedChannels.setListData(mappedChannels);
- setButtons();
+ //String selectedChannelToMap = jComboBoxChannelToMap.getSelectedItem().toString();
+ int selectedChannelToMapIndex = jComboBoxChannelToMap.getSelectedIndex();
+ //String[] taskAndChannelSelected = MappingPatternChannel.seperateTaskAndChannel(selectedChannelToMap);
+ if (selectedChannelToMapIndex >= 0) {
+ MappingPatternChannel mappingPatternChannel = channelsToMapList.get(selectedChannelToMapIndex);
+ if (jRadioMapChannelInExistingMem.isSelected()) {
+ int selectedChannelSameMemIndex = jComboBoxMapChannelInSameMemAs.getSelectedIndex();
+ if (selectedChannelSameMemIndex >= 0) {
+ MappingPatternChannel mappingPatternChannelSameMem = channelsToMapInSameMemList.get(selectedChannelSameMemIndex);
+ mappingPatternChannel.setTaskAndChannelInSameMem(mappingPatternChannelSameMem.getTaskOfChannelToMap(), mappingPatternChannelSameMem.getChannelToMapName(), mappingPatternChannelSameMem.getOrigin());
+ }
+ } else if (jRadioMapChannelInNewMem.isSelected()) {
+ mappingPatternChannel.setBusNameForNewMem(jComboBoxMapChannelInNewMem.getSelectedItem().toString());
+ }
+ mappedChannels.add(mappingPatternChannel.getStringDisplay());
+ channelsToMap.remove(mappingPatternChannel.getTaskChannelToMap());
+ channelsToMapList.remove(mappingPatternChannel);
+ mappedChannelsList.add(mappingPatternChannel);
+ channelsToMapInSameMem.add(mappingPatternChannel.getTaskChannelToMap());
+ channelsToMapInSameMemList.add(mappingPatternChannel);
+ jComboBoxChannelToMap.setSelectedIndex(-1);
+ jListMappedChannels.setListData(mappedChannels);
+ setButtons();
+ }
}
private void removeMappedChannel() {
int[] list = jListMappedChannels.getSelectedIndices();
- Vector<String> v = new Vector<String>();
- String o;
+ List<MappingPatternChannel> mappingPatternChannelsToRemove = new ArrayList<MappingPatternChannel>();
for (int i = 0; i < list.length; i++) {
- o = mappedChannels.elementAt(list[i]);
- String[] splitONew = o.split(MAP_CHANNEL_IN_NEW_MEMORY_SEPARATOR);
- String[] splitOSame = o.split(MAP_CHANNEL_IN_SAME_MEMORY_SEPARATOR);
- if (splitONew.length > 1) {
- channelsToMap.add(splitONew[0]);
- channelsToMapInSameMem.remove(splitONew[0]);
- } else if (splitOSame.length > 1) {
- channelsToMap.add(splitOSame[0]);
- channelsToMapInSameMem.remove(splitOSame[0]);
- }
- v.addElement(o);
+ MappingPatternChannel mappingPatternChannelSelected = mappedChannelsList.get(list[i]);
+ channelsToMap.add(mappingPatternChannelSelected.getTaskChannelToMap());
+ channelsToMapList.add(mappingPatternChannelSelected);
+ channelsToMapInSameMem.remove(mappingPatternChannelSelected.getTaskChannelToMap());
+ channelsToMapInSameMemList.remove(mappingPatternChannelSelected);
+ mappingPatternChannelsToRemove.add(mappingPatternChannelSelected);
+ mappedChannels.remove(list[i]);
}
- mappedChannels.removeAll(v);
+ mappedChannelsList.removeAll(mappingPatternChannelsToRemove);
jListMappedChannels.setListData(mappedChannels);
jComboBoxChannelToMap.setSelectedIndex(-1);
setButtons();
@@ -1957,9 +1792,9 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
//Vector<String> patternTasksVector = new Vector<String>();
tasksOfPatternWithExternalPort.removeAllElements();
clonedTasks.removeAllElements();
+ clonedTasksList.clear();
for (String pTaskName : patternTasksNotConnected.keySet()) {
if (patternTasksNotConnected.get(pTaskName).getExternalPorts().size() > 0) {
- TraceManager.addDev("pTaskName=" + pTaskName);
tasksOfPatternWithExternalPort.add(pTaskName);
}
}
@@ -1973,21 +1808,24 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
buttonCloneTask.setEnabled(true);
removeConnectionBetweenPorts.setEnabled(true);
connectedPorts.removeAllElements();
- connectedPortsFull.removeAllElements();
+ patternConnectionList.clear();
jListConnectedPorts.setListData(connectedPorts);
portsConfig.removeAllElements();
configuredPorts.removeAllElements();
mappedTasks.removeAllElements();
+ mappedTasksList.clear();
tasksToMap.removeAllElements();
+ tasksToMapList.clear();
channelsToMap.removeAllElements();
+ channelsToMapList.clear();
mappedChannels.removeAllElements();
+ mappedChannelsList.clear();
}
if (evt.getSource() == jComboBoxPatternsTaskWithExternalPort) {
externalPortsOfTaskInPattern.removeAllElements();
if (jComboBoxPatternsTaskWithExternalPort.getSelectedIndex() >= 0) {
for (PortTaskJsonFile portTask : patternTasksNotConnected.get(jComboBoxPatternsTaskWithExternalPort.getSelectedItem().toString()).getExternalPorts()) {
externalPortsOfTaskInPattern.add(portTask.getName());
- TraceManager.addDev("portTaskName=" + portTask.getName());
}
jComboBoxPatternExternalPortOfATask.setEnabled(true);
} else {
@@ -2000,24 +1838,15 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
removeConfigPorts.setEnabled(true);
configuredPorts.removeAllElements();
portsConfig.removeAllElements();
- portsTaskConfig = getPortsToConfig(portsTaskOfModelAll, portsTaskOfModelLeft, mgui.gtm.getTMLMapping().getTMLModeling());
- for (String st : portsTaskConfig.keySet()) {
- for (String wc : portsTaskConfig.get(st).getWriteChannels()) {
- //portsConfig.add(st + TASK_CHANNEL_SEPARATOR + wc);
- configuredPorts.add(st + TASK_CHANNEL_SEPARATOR + wc + PORT_CONFIGURATION_SEPARATOR + REMOVE_PORT_OPTION);
- }
- for (String rc : portsTaskConfig.get(st).getReadChannels()) {
- //portsConfig.add(st + TASK_CHANNEL_SEPARATOR + rc);
- configuredPorts.add(st + TASK_CHANNEL_SEPARATOR + rc + PORT_CONFIGURATION_SEPARATOR + REMOVE_PORT_OPTION);
- }
- for (String se : portsTaskConfig.get(st).getSendEvents()) {
- //portsConfig.add(st + TASK_CHANNEL_SEPARATOR + se);
- configuredPorts.add(st + TASK_CHANNEL_SEPARATOR + se + PORT_CONFIGURATION_SEPARATOR + REMOVE_PORT_OPTION);
- }
- for (String we : portsTaskConfig.get(st).getWaitEvents()) {
- //portsConfig.add(st + TASK_CHANNEL_SEPARATOR + we);
- configuredPorts.add(st + TASK_CHANNEL_SEPARATOR + we + PORT_CONFIGURATION_SEPARATOR + REMOVE_PORT_OPTION);
- }
+ List<String> clonedTasksAll = new ArrayList<String>();
+ for (PatternCloneTask cloneT : clonedTasksList) {
+ clonedTasksAll.add(cloneT.getClonedTask());
+ }
+ portsTaskConfig = PatternPortsConfig.getPortsToConfig(portsTaskOfModelAll, portsTaskOfModelLeft, clonedTasksAll, mgui.gtm.getTMLMapping().getTMLModeling());
+ for (PatternPortsConfig portTaskConfig : portsTaskConfig) {
+ portTaskConfig.setIsChannelToRemove(true);
+ configuredPorts.add(portTaskConfig.getStringDisplay());
+ configuredPortsList.add(portTaskConfig);
}
jListConfigPorts.setListData(configuredPorts);
jComboBoxPortsConfig.setSelectedIndex(-1);
@@ -2029,9 +1858,13 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
jComboBoxPortsConfig.setEnabled(false);
removeConfigPorts.setEnabled(false);
mappedTasks.removeAllElements();
+ mappedTasksList.clear();
tasksToMap.removeAllElements();
+ tasksToMapList.clear();
channelsToMap.removeAllElements();
+ channelsToMapList.clear();
mappedChannels.removeAllElements();
+ mappedChannelsList.clear();
buttonTasksMapInArch.setEnabled(false);
buttonChannelsMapInArch.setEnabled(false);
buttonUpdatePatternsAttributes.setEnabled(false);
@@ -2062,32 +1895,22 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
if (!jCheckBoxConnectToNewPort.isSelected()) {
String modeSelectedPatternPort = patternTasksNotConnected.get(selectedPatternTask).getExternalPorts().get(selectedIndexPatternPort).getMode();
String typeSelectedPatternPort = patternTasksNotConnected.get(selectedPatternTask).getExternalPorts().get(selectedIndexPatternPort).getType();
- TraceManager.addDev("modeSelectedPatternPort=" + modeSelectedPatternPort);
- TraceManager.addDev("typeSelectedPatternPort=" + typeSelectedPatternPort);
if (typeSelectedPatternPort.equals(PatternCreation.CHANNEL)) {
- TraceManager.addDev("selectedModelTask0=" + selectedModelTask);
if (modeSelectedPatternPort.equals(PatternCreation.MODE_INPUT)) {
- TraceManager.addDev("selectedModelTas1k=" + selectedModelTask);
- TraceManager.addDev("portsTaskOfModelLeft.get(selectedModelTask).getWriteChannels()=" + portsTaskOfModelLeft.get(selectedModelTask).getWriteChannels().size());
- //portsOfTaskInModel = new Vector<String>(portsTaskOfModelLeft.get(selectedModelTask).getWriteChannels());
for (String st : portsTaskOfModelLeft.get(selectedModelTask).getWriteChannels()) {
portsOfTaskInModel.add(st);
}
} else if (modeSelectedPatternPort.equals(PatternCreation.MODE_OUTPUT)) {
- //portsOfTaskInModel = new Vector<String>(portsTaskOfModelLeft.get(selectedModelTask).getReadChannels());
- TraceManager.addDev("selectedModelTask2=" + selectedModelTask);
for (String st : portsTaskOfModelLeft.get(selectedModelTask).getReadChannels()) {
portsOfTaskInModel.add(st);
}
}
} else if (typeSelectedPatternPort.equals(PatternCreation.EVENT)) {
if (modeSelectedPatternPort.equals(PatternCreation.MODE_INPUT)) {
- //portsOfTaskInModel = new Vector<String>(portsTaskOfModelLeft.get(selectedModelTask).getSendEvents());
for (String st : portsTaskOfModelLeft.get(selectedModelTask).getSendEvents()) {
portsOfTaskInModel.add(st);
}
} else if (modeSelectedPatternPort.equals(PatternCreation.MODE_OUTPUT)) {
- //portsOfTaskInModel = new Vector<String>(portsTaskOfModelLeft.get(selectedModelTask).getWaitEvents());
for (String st : portsTaskOfModelLeft.get(selectedModelTask).getWaitEvents()) {
portsOfTaskInModel.add(st);
}
@@ -2108,7 +1931,6 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
}
}
for (String st : portsOfTaskInModel) {
- TraceManager.addDev("portsOfTaskInModel=" + st);
}
} else {
@@ -2151,24 +1973,6 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
jLabelAddAuthenticity.setVisible(false);
}
}
- /*if (evt.getSource() == jCheckBoxConnectToNewPort) {
- portsOfTaskInModel.removeAllElements();
- String selectedModelTask = jComboBoxModelsTask.getSelectedItem().toString();
- if (jCheckBoxConnectToNewPort.isSelected()) {
- for (String st : portsTaskOfModelLeft.get(selectedModelTask).getWriteChannels()) {
- portsOfTaskInModel.add(st);
- }
- for (String st : portsTaskOfModelLeft.get(selectedModelTask).getReadChannels()) {
- portsOfTaskInModel.add(st);
- }
- for (String st : portsTaskOfModelLeft.get(selectedModelTask).getSendEvents()) {
- portsOfTaskInModel.add(st);
- }
- for (String st : portsTaskOfModelLeft.get(selectedModelTask).getWaitEvents()) {
- portsOfTaskInModel.add(st);
- }
- }
- }*/
if (evt.getSource() == jComboBoxTaskToClone) {
if (jComboBoxTaskToClone.getSelectedIndex() >= 0) {
jFieldNewClonedTaskName.setEnabled(true);
@@ -2190,92 +1994,50 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
}
if (portsConfig.size() == 0 && tasksOfPatternWithExternalPort.size() == 0) {
tasksToMap.removeAllElements();
+ tasksToMapList.clear();
tasksToMapInSameHw.removeAllElements();
+ tasksToMapInSameHwList.clear();
mappedTasks.removeAllElements();
+ mappedTasksList.clear();
channelsToMap.removeAllElements();
+ channelsToMapList.clear();
channelsToMapInSameMem.removeAllElements();
+ channelsToMapInSameMemList.clear();
mappedChannels.removeAllElements();
- for(String st : clonedTasksName) {
- tasksToMap.add(st);
+ mappedChannelsList.clear();
+ List<String> clonedTasksName = new ArrayList<String>();
+ for(PatternCloneTask cloneT: clonedTasksList) {
+ tasksToMap.add(cloneT.getClonedTask());
+ MappingPatternTask mapTask = new MappingPatternTask(cloneT.getClonedTask(), MappingPatternTask.ORIGIN_CLONE);
+ tasksToMapList.add(mapTask);
+ clonedTasksName.add(cloneT.getClonedTask());
}
for(String st : patternTasksAll.keySet()) {
tasksToMap.add(st);
+ MappingPatternTask mapTask = new MappingPatternTask(st, MappingPatternTask.ORIGIN_PATTERN);
+ tasksToMapList.add(mapTask);
}
for(String st : portsTaskOfModelAll.keySet()) {
if (!clonedTasksName.contains(st)) {
tasksToMapInSameHw.add(st);
+ MappingPatternTask mapTask = new MappingPatternTask(st, MappingPatternTask.ORIGIN_MODEL);
+ tasksToMapInSameHwList.add(mapTask);
}
}
-
- /*for(String st : portsTaskOfModelAll.keySet()) {
- if (clonedTasksName.contains(st)) {
- for (String wc : portsTaskOfModelAll.get(st).getWriteChannels()) {
- if (!portsTaskOfModelLeft.get(st).getWriteChannels().contains(wc)) {
- channelsToMap.add(st+TASK_CHANNEL_SEPARATOR+wc);
- }
- }
- for (String rc : portsTaskOfModelAll.get(st).getReadChannels()) {
- if (!portsTaskOfModelLeft.get(st).getReadChannels().contains(rc)) {
- channelsToMap.add(st+TASK_CHANNEL_SEPARATOR+rc);
- }
- }
- }
- }*/
- for(String st : patternTasksAll.keySet()) {
- for (PortTaskJsonFile portTaskJsonFile : patternTasksAll.get(st).getExternalPorts()) {
- if (portTaskJsonFile.getType().equals(PatternCreation.CHANNEL)) {
- boolean isChToMap = true;
- for (String chToMap : channelsToMap) {
- if (chToMap.split(TASK_CHANNEL_SEPARATOR)[1].equals(portTaskJsonFile.getName())) {
- isChToMap = false;
- break;
- }
- }
- if (isChToMap) {
- channelsToMap.add(st+TASK_CHANNEL_SEPARATOR+portTaskJsonFile.getName());
- }
- }
- }
- for (PortTaskJsonFile portTaskJsonFile : patternTasksAll.get(st).getInternalPorts()) {
- if (portTaskJsonFile.getType().equals(PatternCreation.CHANNEL)) {
- boolean isChToMap = true;
- for (String chToMap : channelsToMap) {
- if (chToMap.split(TASK_CHANNEL_SEPARATOR)[1].equals(portTaskJsonFile.getName())) {
- isChToMap = false;
- break;
- }
- }
- if (isChToMap) {
- channelsToMap.add(st+TASK_CHANNEL_SEPARATOR+portTaskJsonFile.getName());
- }
- }
- }
+ List<MappingPatternChannel> channelsToMapListA = MappingPatternChannel.getChannelsToMap(patternConnectionList, patternTasksAll, clonedTasksList);
+ for(MappingPatternChannel channelToMap : channelsToMapListA) {
+ channelsToMap.add(channelToMap.getTaskChannelToMap());
+ channelsToMapList.add(channelToMap);
}
+
for(String st : portsTaskOfModelAll.keySet()) {
if (!clonedTasksName.contains(st)) {
for (String wc : portsTaskOfModelAll.get(st).getWriteChannels()) {
- boolean isChToMap = true;
- for (String chToMap : channelsToMapInSameMem) {
- if (chToMap.split(TASK_CHANNEL_SEPARATOR)[1].equals(wc)) {
- isChToMap = false;
- break;
- }
- }
- if (isChToMap) {
- channelsToMapInSameMem.add(st+TASK_CHANNEL_SEPARATOR+wc);
- }
- }
- for (String rc : portsTaskOfModelAll.get(st).getReadChannels()) {
- boolean isChToMap = true;
- for (String chToMap : channelsToMapInSameMem) {
- if (chToMap.split(TASK_CHANNEL_SEPARATOR)[1].equals(rc)) {
- isChToMap = false;
- break;
- }
- }
- if (isChToMap) {
- channelsToMapInSameMem.add(st+TASK_CHANNEL_SEPARATOR+rc);
- }
+ if (!channelsToMapInSameMem.contains(MappingPatternChannel.getTaskChannel(st, wc))) {
+ MappingPatternChannel mappingPatternChannel = new MappingPatternChannel(st, wc, MappingPatternChannel.ORIGIN_MODEL);
+ channelsToMapInSameMem.add(mappingPatternChannel.getTaskChannelToMap());
+ channelsToMapInSameMemList.add(mappingPatternChannel);
+ }
}
}
}
@@ -2304,25 +2066,12 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
if (jRadioPortConfigMerge.isSelected()) {
jComboBoxPortsConfigMerge.setEnabled(true);
String jCo = jComboBoxPortsConfig.getSelectedItem().toString();
- String[] taskPortSelected = jCo.split(TASK_CHANNEL_SEPARATOR);
+ String[] taskPortSelected = PatternPortsConfig.seperateTaskAndChannel(jCo);
String taskSelected = taskPortSelected[0];
- String portSelected = taskPortSelected[1];
List<String> portsToConfOfTaskAll = new ArrayList<String>();
- for (String st : portsConfig) {
- String[] taskPort = st.split(TASK_CHANNEL_SEPARATOR);
- String task = taskPort[0];
- String port = taskPort[1];
- if (taskSelected.equals(task)) {
- portsToConfOfTaskAll.add(port);
- }
- }
- for (String st : configuredPorts) {
- String[] tp = st.split(PORT_CONFIGURATION_SEPARATOR);
- String[] taskPort = tp[0].split(TASK_CHANNEL_SEPARATOR);
- String task = taskPort[0];
- String port = taskPort[1];
- if (taskSelected.equals(task)) {
- portsToConfOfTaskAll.add(port);
+ for (PatternPortsConfig portTaskConfig : portsTaskConfig) {
+ if (taskSelected.equals(portTaskConfig.getTaskOfChannelToConfig())) {
+ portsToConfOfTaskAll.add(portTaskConfig.getChannelToConfig());
}
}
for (String wc : portsTaskOfModelAll.get(taskSelected).getWriteChannels()) {
@@ -2564,7 +2313,7 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
}*/
if (!findErr) {
- mgui.gtm.createPattern(mgui, selectedTasksAsPattern, newPatternName, pathPatterns);
+ mgui.gtm.createPattern(selectedTasksAsPattern, newPatternName, pathPatterns);
JLabel label = new JLabel("Pattern Creation Completed");
label.setAlignmentX(Component.LEFT_ALIGNMENT);
this.jta.add(label, this.createGbc(currentPosY));
@@ -2592,50 +2341,50 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
int selectedPatternIndex = jComboBoxPatterns.getSelectedIndex();
String selectedPatternPath = pathPatterns+listPatterns.get(selectedPatternIndex)+"/";
String selectedPatternName = listPatterns.get(selectedPatternIndex);
- PatternConfiguration patternConfiguration = new PatternConfiguration();
- patternConfiguration.loadClonedTasks(clonedTasks);
- patternConfiguration.loadConnectedPorts(connectedPortsFull);
- patternConfiguration.loadPortsConfig(configuredPorts);
- patternConfiguration.loadMappedTasks(mappedTasks);
- patternConfiguration.loadMappedChannels(mappedChannels);
- patternConfiguration.setUpdatedPatternAttributes(updatedPatternAttributes);
+
for (String taskName : patternTasksAll.keySet()) {
for (PortTaskJsonFile portTaskExt : patternTasksAll.get(taskName).getExternalPorts()) {
if (portTaskExt.getType().equals(PatternCreation.CHANNEL)) {
if (portTaskExt.getConfidentiality().toUpperCase().equals(PatternCreation.WITH_CONFIDENTIALITY.toUpperCase()) || !portTaskExt.getAuthenticity().toUpperCase().equals(PatternCreation.WITHOUT_AUTHENTICITY.toUpperCase())) {
- if (channelsWithSecurity.containsKey(taskName)) {
- channelsWithSecurity.get(taskName).add(portTaskExt);
- } else {
- List<PortTaskJsonFile> channelsWithSecurityList = new ArrayList<PortTaskJsonFile>();
- channelsWithSecurityList.add(portTaskExt);
- channelsWithSecurity.put(taskName, channelsWithSecurityList);
+ PatternChannelWithSecurity patternChannelWithSecurity = new PatternChannelWithSecurity(taskName, portTaskExt.getName(), portTaskExt.getMode());
+ if (portTaskExt.getConfidentiality().toUpperCase().equals(PatternCreation.WITH_CONFIDENTIALITY.toUpperCase())) {
+ patternChannelWithSecurity.setIsConfidential(true);
+ } else if (portTaskExt.getConfidentiality().toUpperCase().equals(PatternCreation.WITHOUT_CONFIDENTIALITY.toUpperCase())) {
+ patternChannelWithSecurity.setIsConfidential(false);
}
+ if (portTaskExt.getAuthenticity().toUpperCase().equals(PatternCreation.WITHOUT_AUTHENTICITY.toUpperCase())) {
+ patternChannelWithSecurity.setAuthenticity(PatternChannelWithSecurity.NO_AUTHENTICITY);
+ } else if (portTaskExt.getAuthenticity().toUpperCase().equals(PatternCreation.WEAK_AUTHENTICITY.toUpperCase())) {
+ patternChannelWithSecurity.setAuthenticity(PatternChannelWithSecurity.WEAK_AUTHENTICITY);
+ } else if (portTaskExt.getAuthenticity().toUpperCase().equals(PatternCreation.STRONG_AUTHENTICITY.toUpperCase())) {
+ patternChannelWithSecurity.setAuthenticity(PatternChannelWithSecurity.STRONG_AUTHENTICITY);
+ }
+ channelsWithSecurity.add(patternChannelWithSecurity);
}
}
}
for (PortTaskJsonFile portTaskInt : patternTasksAll.get(taskName).getInternalPorts()) {
if (portTaskInt.getType().equals(PatternCreation.CHANNEL)) {
if (portTaskInt.getConfidentiality().toUpperCase().equals(PatternCreation.WITH_CONFIDENTIALITY.toUpperCase()) || !portTaskInt.getAuthenticity().toUpperCase().equals(PatternCreation.WITHOUT_AUTHENTICITY.toUpperCase())) {
- if (channelsWithSecurity.containsKey(taskName)) {
- channelsWithSecurity.get(taskName).add(portTaskInt);
- } else {
- List<PortTaskJsonFile> channelsWithSecurityList = new ArrayList<PortTaskJsonFile>();
- channelsWithSecurityList.add(portTaskInt);
- channelsWithSecurity.put(taskName, channelsWithSecurityList);
+ PatternChannelWithSecurity patternChannelWithSecurity = new PatternChannelWithSecurity(taskName, portTaskInt.getName(), portTaskInt.getMode());
+ if (portTaskInt.getConfidentiality().toUpperCase().equals(PatternCreation.WITH_CONFIDENTIALITY.toUpperCase())) {
+ patternChannelWithSecurity.setIsConfidential(true);
+ } else if (portTaskInt.getConfidentiality().toUpperCase().equals(PatternCreation.WITHOUT_CONFIDENTIALITY.toUpperCase())) {
+ patternChannelWithSecurity.setIsConfidential(false);
}
+ if (portTaskInt.getAuthenticity().toUpperCase().equals(PatternCreation.WITHOUT_AUTHENTICITY.toUpperCase())) {
+ patternChannelWithSecurity.setAuthenticity(PatternChannelWithSecurity.NO_AUTHENTICITY);
+ } else if (portTaskInt.getAuthenticity().toUpperCase().equals(PatternCreation.WEAK_AUTHENTICITY.toUpperCase())) {
+ patternChannelWithSecurity.setAuthenticity(PatternChannelWithSecurity.WEAK_AUTHENTICITY);
+ } else if (portTaskInt.getAuthenticity().toUpperCase().equals(PatternCreation.STRONG_AUTHENTICITY.toUpperCase())) {
+ patternChannelWithSecurity.setAuthenticity(PatternChannelWithSecurity.STRONG_AUTHENTICITY);
+ }
+ channelsWithSecurity.add(patternChannelWithSecurity);
}
}
}
}
- for(String taskCh : channelsWithSecurity.keySet()) {
- TraceManager.addDev("taskCh=" + taskCh);
- for (PortTaskJsonFile portTask : channelsWithSecurity.get(taskCh)) {
- TraceManager.addDev("portTask Name=" + portTask.getName());
- TraceManager.addDev("portTask Conf=" + portTask.getConfidentiality());
- TraceManager.addDev("portTask Auth=" + portTask.getAuthenticity());
- }
- }
- patternConfiguration.setChannelsWithSecurity(channelsWithSecurity);
+ PatternConfiguration patternConfiguration = new PatternConfiguration(patternConnectionList, clonedTasksList, configuredPortsList, mappedTasksList, mappedChannelsList, updatedPatternAttributes, channelsWithSecurity);
mgui.gtm.createJsonPatternConfigFile(selectedPatternPath, selectedPatternName, patternConfiguration);
mgui.gtm.integratePattern(mgui, selectedPatternPath, selectedPatternName);
JLabel label = new JLabel("Pattern Configuration Completed");
@@ -2701,42 +2450,6 @@ public class JDialogPatternHandling extends JDialog implements ActionListener, L
break;
}
}
- /*
- private class AttributeTaskJsonFile {
- String name;
- String type;
- String value;
-
- AttributeTaskJsonFile(String name, String type, String value) {
- this.getName() = name;
- this.getType() = type;
- this.getValue() = value;
- }
- }
-
- private class PortTaskJsonFile {
- String name;
- String type;
- String mode;
-
- PortTaskJsonFile(String name, String type, String mode) {
- this.getName() = name;
- this.getType() = type;
- this.getMode() = mode;
- }
- }
-
- private class TaskPattern {
- List<AttributeTaskJsonFile> attributes;
- List<PortTaskJsonFile> internalPorts;
- List<PortTaskJsonFile> externalPorts;
-
- TaskPattern(List<AttributeTaskJsonFile> attributes, List<PortTaskJsonFile> internalPorts, List<PortTaskJsonFile> externalPorts) {
- this.getAttributes() = attributes;
- this.getInternalPorts() = internalPorts;
- this.getExternalPorts() = externalPorts;
- }
- } */
@Override
public void setError() {