/* 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.
*/
package ui;
import req.ebrdd.*;
import tmltranslator.TMLType;
import translator.CheckingError;
import ui.ebrdd.EBRDDAttributeBox;
import ui.ebrdd.EBRDDPanel;
import ui.ebrdd.EBRDDStartState;
import ui.ebrdd.TGConnectorEBRDDERC;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Vector;
/**
* Class EBRDDTranslator
* Creation: 18/09/2009
* @author Ludovic APVRILLE
*/
public class EBRDDTranslator {
protected EBRDD ebrdd;
protected LinkedList<CheckingError> checkingErrors, warnings;
protected CorrespondanceTGElement listE; // usual list
//protected CorrespondanceTGElement listB; // list for particular element -> first element of group of blocks
public EBRDDTranslator() {
reinit();
}
public void reinit() {
checkingErrors = new LinkedList<CheckingError> ();
warnings = new LinkedList<CheckingError> ();
listE = new CorrespondanceTGElement();
//listB = new CorrespondanceTGElement();
}
public LinkedList<CheckingError> getErrors() {
return checkingErrors;
}
public LinkedList<CheckingError> getWarnings() {
return warnings;
}
private void addCheckingError(CheckingError ce) {
if (checkingErrors == null) {
checkingErrors = new LinkedList<CheckingError> ();
}
checkingErrors.add (ce);
}
private void addWarning(CheckingError ce) {
if (warnings == null) {
warnings = new LinkedList<CheckingError> ();
}
warnings.add (ce);
}
public CorrespondanceTGElement getCorrespondanceTGElement() {
return listE;
}
public EBRDD generateEBRDD(EBRDDPanel ebrddp, String _name) {
ebrdd = new EBRDD(_name);
// Search for start state
List<TGComponent> list = ebrddp.getComponentList();
Iterator<TGComponent> iterator = list.listIterator();
TGComponent tgc, tgc1, tgc2, tgc3, tgc1tmp, tgc2tmp;
TGComponent tss = null;
int cptStart = 0;
while(iterator.hasNext()) {
tgc = iterator.next();
if (tgc instanceof EBRDDStartState){
tss = tgc;
cptStart ++;
}
}
if (tss == null) {
UICheckingError ce = new UICheckingError(CheckingError.BEHAVIOR_ERROR, "No start state in EBRDD");
ce.setTDiagramPanel(ebrddp);
addCheckingError(ce);
return ebrdd;
}
if (cptStart > 1) {
UICheckingError ce = new UICheckingError(CheckingError.BEHAVIOR_ERROR, "More than one start state in EBRDD");
ce.setTDiagramPanel(ebrddp);
addCheckingError(ce);
return ebrdd;
}
req.ebrdd.EBRDDActionState acst;
req.ebrdd.EBRDDChoice ch;
req.ebrdd.EBRDDERC erc;
req.ebrdd.EBRDDLoop loop;
req.ebrdd.EBRDDSequence seq;
req.ebrdd.EBRDDStart start;
req.ebrdd.EBRDDStop stop;
req.ebrdd.EBRDDAttribute attr;
ESO eso;
ERB erb;
TMLType tt;
int i;
int cpt=0;
start = ebrdd.getStartState();
listE.addCor(start, tss);
// Creation of other elements
iterator = list.listIterator();
while(iterator.hasNext()) {
cpt++;
tgc = iterator.next();
// Variables
if (tgc instanceof EBRDDAttributeBox) {
LinkedList<TAttribute> vv = ((EBRDDAttributeBox)tgc).getAttributeList();
for (TAttribute ta: vv) {
if (ta.getType() == TAttribute.NATURAL) {
tt = new TMLType(TMLType.NATURAL);
} else if (ta.getType() == TAttribute.BOOLEAN) {
tt = new TMLType(TMLType.BOOLEAN);
} else {
tt = new TMLType(TMLType.OTHER);
}
attr = new EBRDDAttribute(ta.getId(), ta.getInitialValue(), tt);
if (!ebrdd.addAttribute(attr)) {
UICheckingError ce = new UICheckingError(CheckingError.STRUCTURE_ERROR, "Duplicate declaration for variable " + ta.getId());
ce.setTDiagramPanel(ebrddp);
ce.setTGComponent(tgc);
checkingErrors.add(ce);
}
}
// Action
} else if (tgc instanceof ui.ebrdd.EBRDDActionState) {
acst = new req.ebrdd.EBRDDActionState("Action state"+cpt, tgc);
acst.setAction(((ui.ebrdd.EBRDDActionState)tgc).getAction());
listE.addCor(acst, tgc);
// Stop
} else if (tgc instanceof ui.ebrdd.EBRDDStopState) {
stop = new req.ebrdd.EBRDDStop("Stop"+cpt, tgc);
listE.addCor(stop, tgc);
// Choice
} else if (tgc instanceof ui.ebrdd.EBRDDChoice) {
// guards are added later on
ch = new req.ebrdd.EBRDDChoice("Choice"+cpt, tgc);
listE.addCor(ch, tgc);
// Sequence
} else if (tgc instanceof ui.ebrdd.EBRDDSequence) {
// guards are added later on
seq = new req.ebrdd.EBRDDSequence("Sequence"+cpt, tgc);
listE.addCor(seq, tgc);
// Loop
} else if (tgc instanceof ui.ebrdd.EBRDDForLoop) {
// guards are added later on
loop = new req.ebrdd.EBRDDLoop("Loop"+cpt, tgc);
listE.addCor(loop, tgc);
loop.setInit(((ui.ebrdd.EBRDDForLoop)tgc).getInit());
loop.setCondition(((ui.ebrdd.EBRDDForLoop)tgc).getCondition());
loop.setIncrement(((ui.ebrdd.EBRDDForLoop)tgc).getIncrement());
// ERC
} else if (tgc instanceof ui.ebrdd.EBRDDERC) {
// ERC's internal elements are built later on
erc = new req.ebrdd.EBRDDERC("ERC"+cpt, tgc);
listE.addCor(erc, tgc);
}
}
Vector<Object> v = listE.getData();
Object o;
for(i=0; i<v.size(); i++) {
o = v.get(i);
if (o instanceof EBRDDComponent) {
ebrdd.add((EBRDDComponent)o);
}
}
// Build ERCs
ui.ebrdd.EBRDDESO esotgc;
ui.ebrdd.EBRDDERB erbtgc;
iterator = list.listIterator();
while(iterator.hasNext()) {
tgc = iterator.next();
if (tgc instanceof ui.ebrdd.EBRDDERC) {
erc = (req.ebrdd.EBRDDERC)(listE.getEBRDDGeneralComponent(tgc));
if (erc != null) {
for(i=0; i<tgc.getChildCount(); i++) {
tgc1 = tgc.getInternalTGComponent(i);
if (tgc1 instanceof ui.ebrdd.EBRDDESO) {
esotgc = (ui.ebrdd.EBRDDESO)tgc1;
eso = new req.ebrdd.ESO("ESO"+cpt, esotgc);
listE.addCor(eso, esotgc);
eso.setID(esotgc.getID());
eso.setTimeout(esotgc.getTimeout());
eso.setOncePerEvent(esotgc.getOncePerEvent());
eso.setN(esotgc.getN());
eso.setM(esotgc.getM());
erc.addTreeElement(eso);
} else if (tgc1 instanceof ui.ebrdd.EBRDDERB) {
erbtgc = (ui.ebrdd.EBRDDERB)tgc1;
erb = new req.ebrdd.ERB("ERB" + cpt, erbtgc);
listE.addCor(erb, erbtgc);
erb.setEvent(erbtgc.getEvent());
erb.setAction(erbtgc.getAction());
erb.setCondition(erbtgc.getCondition());
erc.addTreeElement(erb);
}
}
}
}
}
// Interconnection between elements
//TGConnectorEBRDD tgco;
//TGConnectorEBRDDERC tgcoerc;
TGConnector tgco;
TGConnectingPoint p1, p2;
EBRDDComponent eb1, eb2;
EBRDDGeneralComponent ebg1, ebg2;
int j, index;
iterator = list.listIterator();
while(iterator.hasNext()) {
tgc = iterator.next();
if (tgc instanceof TGConnector) {
//tgco = (TGConnectorEBRDD)tgc;
tgco = (TGConnector)tgc;
p1 = tgco.getTGConnectingPointP1();
p2 = tgco.getTGConnectingPointP2();
// Identification of connected components
tgc1 = null; tgc2 = null;
for(j=0; j<list.size(); j++) {
tgc3 = list.get(j);
tgc1tmp = tgc3.belongsToMeOrSon(p1);
tgc2tmp = tgc3.belongsToMeOrSon(p2);
if (tgc1tmp != null) {
tgc1 = tgc1tmp;
}
if (tgc2tmp != null) {
tgc2 = tgc2tmp;
}
}
// Connecting ebrdd modeling components
if ((tgc1 != null) && (tgc2 != null)) {
//ADComponent ad1, ad2;
ebg1 = listE.getEBRDDGeneralComponent(tgc1);
ebg2 = listE.getEBRDDGeneralComponent(tgc2);
if ((ebg1 != null ) && (ebg2 != null)) {
if ((ebg1 instanceof EBRDDComponent) && (ebg2 instanceof EBRDDComponent)) {
eb1 = (EBRDDComponent)ebg1;
eb2 = (EBRDDComponent)ebg2;
//Special case if "for loop" or if "choice"
if (eb1 instanceof req.ebrdd.EBRDDLoop) {
index = tgc1.indexOf(p1) - 1;
if (index == 0) {
eb1.addNext(0, eb2);
} else {
eb1.addNext(eb2);
}
} else if (eb1 instanceof req.ebrdd.EBRDDChoice) {
index = tgc1.indexOf(p1) - 1;
//
eb1.addNext(eb2);
//
((req.ebrdd.EBRDDChoice)eb1).addGuard(((ui.ebrdd.EBRDDChoice)tgc1).getGuard(index));
} else if (eb1 instanceof req.ebrdd.EBRDDSequence) {
index = tgc1.indexOf(p1) - 1;
((req.ebrdd.EBRDDSequence)eb1).addIndex(index);
eb1.addNext(eb2);
//
} else {
eb1.addNext(eb2);
}
} else if ((ebg1 instanceof ERCElement) && (ebg2 instanceof ERCElement)) {
//
if ((ebg1 instanceof req.ebrdd.ESO) && (tgco instanceof TGConnectorEBRDDERC)) {
index = tgc1.indexOf(p1) - 1;
((req.ebrdd.ESO)ebg1).addIndex(index);
((req.ebrdd.ESO)ebg1).addSon((ERCElement)ebg2);
((ERCElement)ebg2).setNegated(tgco.getNegation());
}
}
}
}
}
}
// Sorting nexts elements of Sequence and ESOs
for(j=0; j<ebrdd.size(); j++) {
eb1 = ebrdd.get(j);
if (eb1 instanceof req.ebrdd.EBRDDSequence) {
((req.ebrdd.EBRDDSequence)eb1).sortNexts();
} else if (eb1 instanceof req.ebrdd.EBRDDERC) {
((req.ebrdd.EBRDDERC)eb1).sortNexts();
}
}
// Check that each "for" has two nexts
// Check that Choice have compatible guards
// Check validity of ERC (no cycles, etc.)
iterator = list.listIterator();
while(iterator.hasNext()) {
tgc = iterator.next();
if (tgc instanceof ui.ebrdd.EBRDDChoice) {
ch = (req.ebrdd.EBRDDChoice)(listE.getEBRDDGeneralComponent(tgc));
ch.orderGuards();
if (ch.hasMoreThanOneElse()) {
UICheckingError ce = new UICheckingError(CheckingError.BEHAVIOR_ERROR, "Choice should have only one [else] guard");
ce.setTDiagramPanel(ebrddp);
ce.setTGComponent(tgc);
checkingErrors.add(ce);
}
} else if (tgc instanceof ui.ebrdd.EBRDDForLoop) {
loop = (req.ebrdd.EBRDDLoop)(listE.getEBRDDGeneralComponent(tgc));
if (loop.getNbNext() != 2) {
UICheckingError ce = new UICheckingError(CheckingError.BEHAVIOR_ERROR, "Loop should have exactly two next elements");
ce.setTDiagramPanel(ebrddp);
ce.setTGComponent(tgc);
checkingErrors.add(ce);
}
} else if (tgc instanceof ui.ebrdd.EBRDDERC) {
erc = (req.ebrdd.EBRDDERC)(listE.getEBRDDGeneralComponent(tgc));
if (!erc.makeRoot()) {
UICheckingError ce = new UICheckingError(CheckingError.BEHAVIOR_ERROR, "Badly formed ERC");
ce.setTDiagramPanel(ebrddp);
ce.setTGComponent(tgc);
checkingErrors.add(ce);
}
}
}
// Remove all elements not reachable from start state
int sizeb = ebrdd.size();
ebrdd.removeAllNonReferencedElts();
int sizea = ebrdd.size();
if (sizeb > sizea) {
UICheckingError ce = new UICheckingError(CheckingError.BEHAVIOR_ERROR, "Non reachable elements have been removed in EBRDD");
ce.setTGComponent(null);
ce.setTDiagramPanel(ebrddp);
addWarning(ce);
//
}
return ebrdd;
}
}