diff --git a/src/ddtranslator/DDStructLink.java b/src/ddtranslator/DDStructLink.java
new file mode 100755
index 0000000000000000000000000000000000000000..6d00a089d84be8c9fe12c2016007dce4920dab2c
--- /dev/null
+++ b/src/ddtranslator/DDStructLink.java
@@ -0,0 +1,62 @@
+/**Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
+
+ludovic.apvrille AT enst.fr
+
+This software is a computer program whose purpose is to allow the
+edition of TURTLE analysis, design and deployment diagrams, to
+allow the generation of RT-LOTOS or Java code from this diagram,
+and at last to allow the analysis of formal validation traces
+obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
+from INRIA Rhone-Alpes.
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software. You can use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty and the software's author, the holder of the
+economic rights, and the successive licensors have only limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading, using, modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean that it is complicated to manipulate, and that also
+therefore means that it is reserved for developers and experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and, more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+/**
+ * Class DDStructLink
+ * Creation: 31/05/2005
+ * version 1.0 31/05/2005
+ * @author Ludovic APVRILLE
+ * @see
+ */
+
+package ddtranslator;
+
+import translator.*;
+
+public class DDStructLink {
+ public Gate lgate;
+ public Gate rgate;
+ public Gate linklg;
+ public Gate linkrg;
+ public boolean added;
+
+ public DDStructLink() {
+ }
+
+
+
+} // Class
\ No newline at end of file
diff --git a/src/ddtranslator/DDStructSynchro.java b/src/ddtranslator/DDStructSynchro.java
new file mode 100755
index 0000000000000000000000000000000000000000..26eff0b8f0be2fe550468aa39595248f627b0170
--- /dev/null
+++ b/src/ddtranslator/DDStructSynchro.java
@@ -0,0 +1,207 @@
+/**Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
+
+ludovic.apvrille AT enst.fr
+
+This software is a computer program whose purpose is to allow the
+edition of TURTLE analysis, design and deployment diagrams, to
+allow the generation of RT-LOTOS or Java code from this diagram,
+and at last to allow the analysis of formal validation traces
+obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
+from INRIA Rhone-Alpes.
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software. You can use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty and the software's author, the holder of the
+economic rights, and the successive licensors have only limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading, using, modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean that it is complicated to manipulate, and that also
+therefore means that it is reserved for developers and experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and, more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+/**
+ * Class DDStructSynchro
+ * Creation: 03/06/2005
+ * version 1.0 03/06/2005
+ * @author Ludovic APVRILLE
+ * @see
+ */
+
+package ddtranslator;
+
+import java.util.*;
+
+import translator.*;
+
+public class DDStructSynchro {
+ private LinkedList list;
+
+ public DDStructSynchro() {
+ list = new LinkedList();
+ }
+
+ public DDStructSynchro(String actionValue, TClass t) {
+ list = new LinkedList();
+ constructList(actionValue, t);
+ }
+
+ // assumes that it contains no "!" operator
+ public void constructList(String actionValue, TClass t) {
+ String stmp, paramName;
+ Param p;
+ char c = '?';
+
+ int index, index1, index2, index3, index4, index5;
+ String s = actionValue;
+
+ if ((s == null) || (s.length() == 0))
+ return;
+
+ while ( (index = s.indexOf(c)) != -1) {
+ stmp = s.substring(index+1, s.length());
+ index1 = stmp.indexOf('!');
+ index2 = stmp.indexOf('?');
+ index3 = stmp.length();
+ if (index1 == -1) {
+ index1 = index3;
+ }
+ if (index2 == -1) {
+ index2 = index3;
+ }
+ index4 = Math.min(index1, index2);
+ index4 = Math.min(index4, index3);
+
+ if (index4 > 0) {
+ paramName = s.substring(index+1, index4+index+1);
+ paramName = paramName.trim();
+ index5 = paramName.indexOf(":");
+ if (index5>0) {
+ paramName = paramName.substring(0, index5);
+ }
+ p = t.getParamByName(paramName);
+ //System.out.println("Param=" + paramName);
+ if (p != null) {
+ list.add(p.getType());
+ } else {
+ return;
+ }
+ }
+ s = s.substring(index4+index+1, s.length());
+ }
+ }
+
+ public String getRegularCall() {
+
+ //System.out.println("synchro size=" + list.size());
+
+ String call = "";
+ int x = 0;
+ int b = 0;
+ String type;
+
+ ListIterator iterator = list.listIterator();
+
+ while(iterator.hasNext()) {
+ type = (String)(iterator.next());
+ if (type.compareTo(Param.NAT) ==0) {
+ call += "?x" + x + ":nat";
+ x ++;
+ } else {
+ call += "?b" + b + ":nat";
+ b ++;
+ }
+ }
+
+ return call;
+ }
+
+ public int nbNat() {
+ int nb = 0;
+ ListIterator iterator = list.listIterator();
+ String type;
+
+ while(iterator.hasNext()) {
+ type = (String)(iterator.next());
+ if (type.compareTo(Param.NAT) ==0) {
+ nb ++;
+ }
+ }
+
+ return nb;
+ }
+
+ public int nbBool() {
+ int nb = 0;
+ ListIterator iterator = list.listIterator();
+ String type;
+ while(iterator.hasNext()) {
+ type = (String)(iterator.next());
+ if (type.compareTo(Param.BOOL) ==0) {
+ nb ++;
+ }
+ }
+
+ return nb;
+ }
+
+ public int compareTo(Object o) {
+ if (o instanceof DDStructSynchro) {
+ DDStructSynchro ddss = (DDStructSynchro)o;
+ LinkedList listd = ddss.getList();
+ if (list.size() == listd.size()) {
+ ListIterator li1 = list.listIterator();
+ ListIterator li2 = listd.listIterator();
+ String s1, s2;
+ while(li1.hasNext()) {
+ s1 = (String)(li1.next());
+ s2 = (String)(li2.next());
+ if (s1.compareTo(s2) != 0) {
+ return -1;
+ }
+ }
+ return 0;
+ }
+ return -1;
+ }
+ return -1;
+ }
+
+ public LinkedList getList() {
+ return list;
+ }
+
+ public int size() {
+ return list.size();
+ }
+
+ public boolean isInList(LinkedList _list) {
+ ListIterator iterator = _list.listIterator();
+ DDStructSynchro ddss;
+ while(iterator.hasNext()) {
+ ddss = (DDStructSynchro)(iterator.next());
+ if (compareTo(ddss) == 0) {
+ return true;
+ }
+ }
+ return false;
+ }
+
+
+
+} // Class
\ No newline at end of file
diff --git a/src/ddtranslator/DDSyntaxException.java b/src/ddtranslator/DDSyntaxException.java
new file mode 100755
index 0000000000000000000000000000000000000000..558b9fd2b4cdb4e8feb1e615578325b092da6ccf
--- /dev/null
+++ b/src/ddtranslator/DDSyntaxException.java
@@ -0,0 +1,59 @@
+/**Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
+
+ludovic.apvrille AT enst.fr
+
+This software is a computer program whose purpose is to allow the
+edition of TURTLE analysis, design and deployment diagrams, to
+allow the generation of RT-LOTOS or Java code from this diagram,
+and at last to allow the analysis of formal validation traces
+obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
+from INRIA Rhone-Alpes.
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software. You can use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty and the software's author, the holder of the
+economic rights, and the successive licensors have only limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading, using, modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean that it is complicated to manipulate, and that also
+therefore means that it is reserved for developers and experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and, more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+/**
+ * Class DDSyntaxException
+ * Creation: 31/05/2005
+ * version 1.0 31/05/2005
+ * @author Ludovic APVRILLE
+ * @see
+ */
+
+package ddtranslator;
+
+
+public class DDSyntaxException extends Exception {
+
+ public DDSyntaxException() {
+ super("DD does not follows the restricted format");
+ }
+
+ public DDSyntaxException(String msg) {
+ super("DD does not follows the restricted format: " + msg);
+ }
+
+} // Class
\ No newline at end of file
diff --git a/src/ddtranslator/DDTranslator.java b/src/ddtranslator/DDTranslator.java
new file mode 100755
index 0000000000000000000000000000000000000000..110531abcfe493a503a761d1e04b8e3c573c5477
--- /dev/null
+++ b/src/ddtranslator/DDTranslator.java
@@ -0,0 +1,276 @@
+/**Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
+
+ludovic.apvrille AT enst.fr
+
+This software is a computer program whose purpose is to allow the
+edition of TURTLE analysis, design and deployment diagrams, to
+allow the generation of RT-LOTOS or Java code from this diagram,
+and at last to allow the analysis of formal validation traces
+obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
+from INRIA Rhone-Alpes.
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software. You can use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty and the software's author, the holder of the
+economic rights, and the successive licensors have only limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading, using, modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean that it is complicated to manipulate, and that also
+therefore means that it is reserved for developers and experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and, more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+/**
+ * Class DDTranslator
+ * Creation: 31/05/2004
+ * @version 1.0 31/05/2004
+ * @author Ludovic APVRILLE
+ * @see
+ */
+
+package ddtranslator;
+
+
+import java.util.*;
+
+
+import translator.*;
+import ui.*;
+import ui.cd.*;
+import ui.dd.*;
+
+public class DDTranslator {
+
+ private TURTLEModeling tm;
+ private DeploymentPanel dp;
+ private CorrespondanceTGElement listE;
+
+ public DDTranslator(DeploymentPanel _dp, TURTLEModeling _tm, CorrespondanceTGElement _listE) {
+ dp = _dp;
+ tm = _tm;
+ listE = _listE;
+ }
+
+
+ public void translateLinks() throws DDSyntaxException {
+
+ // We go throughout links
+ LinkedList ll;
+ ListIterator iterator;
+ TDDNode node;
+ TGConnectorLinkNode link;
+ VectorLRArtifactTClassGate assocs;
+ LRArtifactTClassGate lratg;
+ TClassLinkNode t;
+ TClass tcl;
+ int i;
+
+ ll = dp.tddp.getListOfLinks();
+ iterator = ll.listIterator();
+
+ TClassLinkNode.reinitName();
+
+ // Loop on links
+ while(iterator.hasNext()) {
+ link = (TGConnectorLinkNode)(iterator.next());
+ assocs = link.getList();
+ System.out.println("assocs=" + assocs);
+ if (assocs.size() > 0) {
+ System.out.println("translateLinks : assocs > 0");
+ t = new TClassLinkNode(TClassLinkNode.generateName());
+ t.setDelay(link.getDelay());
+ tm.addTClass(t);
+ t.prepareTClass();
+ for(i=0; i<assocs.size(); i++) {
+ lratg = assocs.getElementAt(i);
+ makeSynchro(link, lratg, t, link.getOriginNode(), link.getDestinationNode());
+ }
+ t.finishTClass();
+ }
+ }
+
+ // Loop on TClassLinkNode
+ /* for(i=0; i<tm.classNb(); i++) {
+ tcl = getTClassAtIndex(i);
+ if (tcl instanceof TClassLinkNode) {
+ t = (TClassLinkNode)tcl;
+
+ }
+ }*/
+ }
+
+ private void makeSynchro(TGConnectorLinkNode link, LRArtifactTClassGate lratg, TClassLinkNode t, TDDNode node1, TDDNode node2) {
+ // Find all possible receiving at destination side
+ TCDTClass gtclass, gtclass2;
+ DDStructSynchro synchro;
+ ActivityDiagram ad;
+ int i;
+ ADComponent adc;
+ Gate g = null;
+ String actionOnGate = null;
+ int maxBool = 0;
+ int maxNat = 0;
+ int id;
+
+ System.out.println("Making synchro");
+
+ // Prepare struct
+ DDStructLink ddsl = new DDStructLink();
+
+ gtclass = findTClass(lratg.left.art, lratg.left.tcl);
+ TClass tclass1 = listE.getTClass(gtclass);
+
+ gtclass2 = findTClass(lratg.right.art, lratg.right.tcl);
+ TClass tclass2 = listE.getTClass(gtclass2);
+
+ System.out.println("Making synchro: step 1 gtclass="+ gtclass.getClassName() + "gtclass2="+ gtclass2.getClassName());
+
+ if ((tclass1 == null) || (tclass2 == null)) {
+ return;
+ }
+
+ System.out.println("Making synchro: step 1 tclass1="+ tclass1.getName() + "tclass2="+ tclass2.getName());
+
+
+ ddsl.lgate = tclass1.getGateByName(lratg.left.gat);
+ ddsl.rgate = tclass2.getGateByName(lratg.right.gat);
+
+ if ((ddsl.lgate == null) || (ddsl.rgate == null)) {
+ return;
+ }
+
+ System.out.println("Making synchro: step 2");
+
+ // Create gates for the link;
+ id = t.getIdGate();
+ ddsl.linklg = t.addNewGateIfApplicable("g_l_" + id);
+ ddsl.linkrg = t.addNewGateIfApplicable("g_r_" + id);
+
+ // Set the right protocol on gates
+ ddsl.lgate.setProtocolJava(link.getImplementation());
+ ddsl.lgate.setLocalPortJava(link.getOriginPort());
+ ddsl.lgate.setDestPortJava(link.getDestinationPort());
+ ddsl.lgate.setDestHostJava(tclass2.getName().substring(0, tclass2.getName().indexOf('_')));
+ ddsl.lgate.setLocalHostJava(tclass1.getName().substring(0, tclass1.getName().indexOf('_')));
+ ddsl.rgate.setProtocolJava(link.getImplementation());
+ ddsl.rgate.setLocalPortJava(link.getDestinationPort());
+ ddsl.rgate.setDestPortJava(link.getOriginPort());
+ ddsl.rgate.setDestHostJava(tclass1.getName().substring(0, tclass1.getName().indexOf('_')));
+ ddsl.rgate.setLocalHostJava(tclass2.getName().substring(0, tclass2.getName().indexOf('_')));
+
+ System.out.println("*** -> Protocol = " + link.getImplementation());
+ System.out.println("*** -> hosts = host1=" + ddsl.lgate.getDestHostJava() + " host2=" + ddsl.rgate.getDestHostJava());
+
+ System.out.println("Toto01 -> looking for gate " + lratg.left.gat);
+
+ // Analyse Tclass1
+
+ System.out.println("Toto02");
+ LinkedList synchros = new LinkedList();
+ ad = tclass1.getActivityDiagram();
+
+ for(i=0; i<ad.size(); i++) {
+ adc = (ADComponent)(ad.elementAt(i));
+ g = null;
+ if (adc instanceof ADActionStateWithGate) {
+ g = ((ADActionStateWithGate)adc).getGate();
+ actionOnGate = ((ADActionStateWithGate)adc).getActionValue();
+ }
+ if (adc instanceof ADTLO) {
+ g = ((ADTLO)adc).getGate();
+ actionOnGate = ((ADTLO)adc).getAction();
+ }
+ if (g != null) {
+ if (g.getName().compareTo(lratg.left.gat) == 0) {
+ System.out.println("Gate=" + g.getName() + " action on gate=" + actionOnGate);
+ synchro = new DDStructSynchro(actionOnGate, tclass1);
+ if ((!(synchro.isInList(synchros))) && (synchro.size() > 0)) {
+ synchros.add(synchro);
+
+ maxBool = Math.max(synchro.nbBool(), maxBool);
+ maxNat = Math.max(synchro.nbNat(), maxNat);
+
+ System.out.println("Adding gate management");
+ ddsl.added = true;
+ t.addGateManagement(ddsl.linkrg, synchro.getRegularCall(), ddsl.linklg);
+ }
+ }
+ }
+ }
+
+ // Do the same at receiving side
+
+ //System.out.println("Toto03");
+ synchros = new LinkedList();
+ ad = tclass2.getActivityDiagram();
+
+ for(i=0; i<ad.size(); i++) {
+ adc = (ADComponent)(ad.elementAt(i));
+ g = null;
+ if (adc instanceof ADActionStateWithGate) {
+ g = ((ADActionStateWithGate)adc).getGate();
+ actionOnGate = ((ADActionStateWithGate)adc).getActionValue();
+ }
+ if (adc instanceof ADTLO) {
+ g = ((ADTLO)adc).getGate();
+ actionOnGate = ((ADTLO)adc).getAction();
+ }
+ if (g != null) {
+ if (g.getName().compareTo(lratg.right.gat) == 0) {
+ synchro = new DDStructSynchro(actionOnGate, tclass2);
+ if ((!(synchro.isInList(synchros))) && (synchro.size() > 0)) {
+ synchros.add(synchro);
+
+ maxBool = Math.max(synchro.nbBool(), maxBool);
+ maxNat = Math.max(synchro.nbNat(), maxNat);
+
+ ddsl.added = true;
+ //System.out.println("Adding gate management");
+ t.addGateManagement(ddsl.linklg, synchro.getRegularCall(), ddsl.linkrg);
+ }
+ }
+ }
+ }
+
+
+ // Add necessary parameters to the tclass
+ t.makeBoolParameters(maxBool);
+ t.makeNatParameters(maxNat);
+
+ // Add synchro relations
+ if (ddsl.added == true) {
+ //System.out.println("Adding synchro relation g1_save = " + g1_save + " g1=" + g1);
+ //System.out.println("Adding synchro relation g1_save = " + g2_save + " g3=" + g3);
+ tm.addSynchroRelation(tclass1, ddsl.lgate, t, ddsl.linklg);
+ tm.addSynchroRelation(t, ddsl.linkrg, tclass2, ddsl.rgate);
+ }
+ }
+
+ private TCDTClass findTClass(String artifact, String tclass) {
+ DesignPanel dpan = dp.tddp.getGUI().getDesignPanel(artifact);
+ if (dpan == null) {
+ return null;
+ }
+
+ return dpan.getTCDTClass(tclass);
+ }
+
+
+
+
+}
\ No newline at end of file
diff --git a/src/ddtranslator/TClassLinkNode.java b/src/ddtranslator/TClassLinkNode.java
new file mode 100755
index 0000000000000000000000000000000000000000..449e31a4fdb74fa341d524fd8e1423e1ee3bf023
--- /dev/null
+++ b/src/ddtranslator/TClassLinkNode.java
@@ -0,0 +1,161 @@
+/**Copyright or (C) or Copr. GET / ENST, Telecom-Paris, Ludovic Apvrille
+
+ludovic.apvrille AT enst.fr
+
+This software is a computer program whose purpose is to allow the
+edition of TURTLE analysis, design and deployment diagrams, to
+allow the generation of RT-LOTOS or Java code from this diagram,
+and at last to allow the analysis of formal validation traces
+obtained from external tools, e.g. RTL from LAAS-CNRS and CADP
+from INRIA Rhone-Alpes.
+
+This software is governed by the CeCILL license under French law and
+abiding by the rules of distribution of free software. You can use,
+modify and/ or redistribute the software under the terms of the CeCILL
+license as circulated by CEA, CNRS and INRIA at the following URL
+"http://www.cecill.info".
+
+As a counterpart to the access to the source code and rights to copy,
+modify and redistribute granted by the license, users are provided only
+with a limited warranty and the software's author, the holder of the
+economic rights, and the successive licensors have only limited
+liability.
+
+In this respect, the user's attention is drawn to the risks associated
+with loading, using, modifying and/or developing or reproducing the
+software by the user in light of its specific status of free software,
+that may mean that it is complicated to manipulate, and that also
+therefore means that it is reserved for developers and experienced
+professionals having in-depth computer knowledge. Users are therefore
+encouraged to load and test the software's suitability as regards their
+requirements in conditions enabling the security of their systems and/or
+data to be ensured and, more generally, to use and operate it in the
+same conditions as regards security.
+
+The fact that you are presently reading this means that you have had
+knowledge of the CeCILL license and that you accept its terms.
+
+ /**
+ * Class TClassLinkNode
+ * Creation: 01/06/2005
+ * @version 1.0 01/06/2005
+ * @author Ludovic APVRILLE
+ * @see
+ */
+
+package ddtranslator;
+
+
+
+import myutil.*;
+import translator.*;
+
+public class TClassLinkNode extends TClass {
+ private static int id = 0;
+
+ private String delay = "10";
+
+ private ADParallel mainpar;
+ private int idGate = 0;
+
+ public TClassLinkNode(String name) {
+ super(name, true);
+ }
+
+ public static String generateName() {
+ id ++;
+ return "Link__" + (id-1);
+ }
+
+ public int getIdGate() {
+ int ret = idGate;
+ idGate ++;
+ return (idGate - 1);
+ }
+
+ public static void reinitName() {
+ id = 0;
+ }
+
+ public void prepareTClass() {
+ ActivityDiagram ad = new ActivityDiagram();
+ mainpar = new ADParallel();
+ ad.getStartState().addNext(mainpar);
+ ad.add(mainpar);
+ setActivityDiagram(ad);
+ }
+
+ /*public Gate addInputGate(String name) {
+
+ }
+
+ public Gate addOutputGate(String name) {
+
+ }*/
+
+ public void addGateManagement(Gate g1, String call, Gate g2) {
+ addGateManagement(g1, call, g2, delay);
+ }
+
+ public void addGateManagement(Gate g1, String call, Gate g2, String delay) {
+ ActivityDiagram ad = getActivityDiagram();
+ ADJunction adj1 = new ADJunction();
+
+ //System.out.println("Call=" + call);
+ ADActionStateWithGate ad1 = new ADActionStateWithGate(g1);
+ ad1.setActionValue(call);
+
+ ADParallel para = new ADParallel();
+
+ ADDelay addelay = new ADDelay();
+ addelay.setValue(delay);
+
+ ADActionStateWithGate ad2 = new ADActionStateWithGate(g2);
+ call = Conversion.replaceAllChar(call, '?', "!");
+ call = Conversion.replaceOp(call, ":nat", "");
+ //System.out.println("Call=" + call);
+ ad2.setActionValue(call);
+
+ ADStop adstop = new ADStop();
+
+ mainpar.addNext(adj1);
+ adj1.addNext(ad1);
+ ad1.addNext(para);
+ para.addNext(adj1);
+ para.addNext(addelay);
+ addelay.addNext(ad2);
+ ad2.addNext(adstop);
+
+ ad.add(adj1);
+ ad.add(ad1);
+ ad.add(para);
+ ad.add(addelay);
+ ad.add(ad2);
+ ad.add(adstop);
+ }
+
+ public void finishTClass() {
+ // Parallel with more than 5 nexts -> manage it !
+
+ }
+
+ public int getNbNext() {
+ return mainpar.getNbNext();
+ }
+
+ public void makeBoolParameters(int nb) {
+ for(int i=0; i<nb; i++) {
+ addNewParamIfApplicable("b" + i, Param.BOOL, "false");
+ }
+ }
+
+ public void makeNatParameters(int nb) {
+ for(int i=0; i<nb; i++) {
+ addNewParamIfApplicable("x" + i, Param.NAT, "0");
+ }
+ }
+
+ public void setDelay(String _delay) {
+ delay = _delay;
+ }
+}
\ No newline at end of file