AttackTreePanelTranslator.java

/* 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 attacktrees.*;
import avatartranslator.*;
import translator.CheckingError;
import ui.atd.*;

import java.util.LinkedList;
import java.util.List;

/**
 * Class AvatarTreePanelTranslator
 * Creation: 13/04/2015
 *
 * @author Ludovic APVRILLE
 */
public class AttackTreePanelTranslator {

    protected AttackTree at;
    protected AttackTreePanel atp;
    protected List<CheckingError> checkingErrors, warnings;
    protected CorrespondanceTGElement listE; // usual list
    //protected CorrespondanceTGElement listB; // list for particular element -> first element of group of blocks
    protected List<TDiagramPanel> panels;


    public AttackTreePanelTranslator(AttackTreePanel _atp) {
        atp = _atp;
        reinit();
    }

    public void reinit() {
        checkingErrors = new LinkedList<CheckingError>();
        warnings = new LinkedList<CheckingError>();
        listE = new CorrespondanceTGElement();
        panels = new LinkedList<TDiagramPanel>();
    }

    public List<CheckingError> getCheckingErrors() {
        return checkingErrors;
    }

    public List<CheckingError> getWarnings() {
        return warnings;
    }

    public CorrespondanceTGElement getCorrespondanceTGElement() {
        return listE;
    }

    public AttackTree translateToAttackTreeDataStructure() {

        at = new AttackTree("AttackTree", atp);


        for (TDiagramPanel panel : atp.panels) {
            if (panel instanceof AttackTreeDiagramPanel) {
                translate((AttackTreeDiagramPanel) panel);
                boolean b = at.checkSyntax();
                if (!b) {
                    UICheckingError ce = new UICheckingError(CheckingError.STRUCTURE_ERROR, at.errorOfFaultyElement);
                    ce.setTGComponent((TGComponent) (at.faultyElement.getReferenceObject()));
                    ce.setTDiagramPanel(panel);
                    addCheckingError(ce);
                }
                return at;
            }
        }


        //TraceManager.addDev("AT=" + at.toString());
        return at;

    }

    public void translate(AttackTreeDiagramPanel atdp) {
        List<TGComponent> allComponents = atdp.getAllComponentList();

        int nodeID = 0;
        TGComponent father;

        //Create attacks, nodes
        for (TGComponent comp : allComponents) {
            if (comp instanceof ATDAttack) {
                ATDAttack atdatt = (ATDAttack) comp;
                Attack att;
                String value = atdatt.getValue();
                father = atdatt.getFather();
                if ((father != null) && (father instanceof ATDBlock)) {
                    value = ((ATDBlock) father).getNodeName() + "__" + value;

                }
                att = new Attack(value, atdatt);
                att.setRoot(atdatt.isRootAttack());
                att.setEnabled(atdatt.isEnabled());
                at.addAttack(att);
                listE.addCor(att, comp);
            }
            if (comp instanceof ATDConstraint) {
                ATDConstraint cons = (ATDConstraint) comp;
                nodeID++;

                //OR
                if (cons.isOR()) {
                    ORNode ornode = new ORNode("OR__" + nodeID, cons);
                    at.addNode(ornode);
                    listE.addCor(ornode, comp);

                    //AND
                } else if (cons.isAND()) {
                    ANDNode andnode = new ANDNode("AND__" + nodeID, cons);
                    at.addNode(andnode);
                    listE.addCor(andnode, comp);

                    //XOR
                } else if (cons.isXOR()) {
                    XORNode xornode = new XORNode("XOR__" + nodeID, cons);
                    at.addNode(xornode);
                    listE.addCor(xornode, comp);

                    //SEQUENCE
                } else if (cons.isSequence()) {
                    SequenceNode seqnode = new SequenceNode("SEQUENCE__" + nodeID, cons);
                    at.addNode(seqnode);
                    listE.addCor(seqnode, comp);

                    //BEFORE
                } else if (cons.isBefore()) {
                    String eq = cons.getEquation();
                    int time;
                    try {
                        time = Integer.decode(eq).intValue();
                        BeforeNode befnode = new BeforeNode("BEFORE__" + nodeID, cons, time);
                        at.addNode(befnode);
                        listE.addCor(befnode, comp);
                    } catch (Exception e) {
                        UICheckingError ce = new UICheckingError(CheckingError.STRUCTURE_ERROR, "Invalid time in before node");
                        ce.setTGComponent(comp);
                        ce.setTDiagramPanel(atdp);
                        addCheckingError(ce);
                    }

                    //AFTER
                } else if (cons.isAfter()) {
                    String eq = cons.getEquation();
                    int time;
                    try {
                        time = Integer.decode(eq).intValue();
                        AfterNode aftnode = new AfterNode("AFTER__" + nodeID, cons, time);
                        at.addNode(aftnode);
                        listE.addCor(aftnode, comp);
                    } catch (Exception e) {
                        UICheckingError ce = new UICheckingError(CheckingError.STRUCTURE_ERROR, "Invalid time in after node");
                        ce.setTGComponent(comp);
                        ce.setTDiagramPanel(atdp);
                        addCheckingError(ce);
                    }

                } else {
                    UICheckingError ce = new UICheckingError(CheckingError.STRUCTURE_ERROR, "Invalid attack node");
                    ce.setTGComponent(comp);