| /* |
| ----------------------------------------------------------------------- |
| -- Ada infrastructural code generator -- |
| -- for the CHESS component model -- |
| -- -- |
| -- Copyright (C) 2011-2012 -- |
| -- University of Padova, ITALY -- |
| -- -- |
| -- Author: Marco Panunzio panunzio@math.unipd.it -- |
| -- -- |
| -- All rights reserved. This program and the accompanying materials -- |
| -- are made available under the terms of the Eclipse Public License -- |
| -- v1.0 which accompanies this distribution, and is available at -- |
| -- http://www.eclipse.org/legal/epl-v10.html -- |
| ----------------------------------------------------------------------- |
| */ |
| |
| /** |
| * 2015/04/03 NP: fixed problem regarding ordering of slots in instances of connectors |
| * in getBoundPIslot (slot 0 instead of slot1) |
| */ |
| |
| package org.polarsys.chess.codegen.ada.service; |
| |
| import java.util.ArrayList; |
| import java.util.List; |
| import java.util.Scanner; |
| |
| import org.eclipse.emf.common.util.EList; |
| import org.eclipse.papyrus.MARTE.MARTE_Annexes.VSL.DataTypes.TupleType; |
| import org.eclipse.papyrus.MARTE.MARTE_DesignModel.GCM.ClientServerKind; |
| import org.eclipse.papyrus.MARTE.MARTE_DesignModel.GCM.ClientServerPort; |
| import org.eclipse.papyrus.MARTE.MARTE_DesignModel.HLAM.CallConcurrencyKind; |
| import org.eclipse.papyrus.MARTE.MARTE_Foundations.Alloc.Assign; |
| import org.eclipse.uml2.uml.Activity; |
| import org.eclipse.uml2.uml.ActivityFinalNode; |
| import org.eclipse.uml2.uml.ActivityNode; |
| import org.eclipse.uml2.uml.Behavior; |
| import org.eclipse.uml2.uml.CallOperationAction; |
| import org.eclipse.uml2.uml.Classifier; |
| import org.eclipse.uml2.uml.Comment; |
| import org.eclipse.uml2.uml.Component; |
| import org.eclipse.uml2.uml.Connector; |
| import org.eclipse.uml2.uml.ConnectorEnd; |
| import org.eclipse.uml2.uml.ControlFlow; |
| import org.eclipse.uml2.uml.DataType; |
| import org.eclipse.uml2.uml.InitialNode; |
| import org.eclipse.uml2.uml.InstanceSpecification; |
| import org.eclipse.uml2.uml.InstanceValue; |
| import org.eclipse.uml2.uml.Interface; |
| import org.eclipse.uml2.uml.NamedElement; |
| import org.eclipse.uml2.uml.Operation; |
| import org.eclipse.uml2.uml.Parameter; |
| import org.eclipse.uml2.uml.Port; |
| import org.eclipse.uml2.uml.PrimitiveType; |
| import org.eclipse.uml2.uml.Property; |
| import org.eclipse.uml2.uml.Slot; |
| import org.eclipse.uml2.uml.Stereotype; |
| import org.eclipse.uml2.uml.Type; |
| import org.eclipse.uml2.uml.ValueSpecification; |
| import org.polarsys.chess.chessmlprofile.ComponentModel.ComponentImplementation; |
| import org.polarsys.chess.chessmlprofile.Dependability.MitigationMeans.TransmissionWithProtocol; |
| import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtPortSlot; |
| import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtSpecification; |
| |
| // TODO: Auto-generated Javadoc |
| /** |
| * The Class UML2Service contains utility methods that are meant to be called from the Acceleo Transformation |
| */ |
| public class UML2Service { |
| |
| /** The Constant DOCSTEREO. */ |
| private static final String DOCSTEREO = "Papyrus::Documentation::Documentation"; |
| // private static final String REQUIREMENT_EXTENSION = "requirement"; |
| // private static final Object LINK = "#Link_to"; |
| |
| /** |
| * Gets the provided interface from a Port (must be stereotyped as ClientServerPort) |
| * |
| * @param port the port |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return the provided interface |
| */ |
| public Interface getProvidedInterface(Port port, String stName) { |
| Stereotype clSvPortSt = port.getAppliedStereotype(stName); |
| ClientServerPort clSvPort = (ClientServerPort) port.getStereotypeApplication(clSvPortSt); |
| // Assumption : 1 PI per Port |
| return clSvPort.getProvInterface().get(0); |
| } |
| |
| /** |
| * Gets the required interface from a Port (must be stereotyped as ClientServerPort) |
| * |
| * @param port the port |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return the required interface |
| */ |
| public Interface getRequiredInterface(Port port, String stName) { |
| Stereotype clSvPortSt = port.getAppliedStereotype(stName); |
| ClientServerPort clSvPort = (ClientServerPort) port.getStereotypeApplication(clSvPortSt); |
| // Assumption : 1 RI per Port |
| return clSvPort.getReqInterface().get(0); |
| } |
| |
| /** |
| * Checks if a specific port is a ClientServerPort which can provide interfaces. |
| * |
| * @param pt the port |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return true if the port is a ClientServerPort of kind PROVIDED, false otherwise |
| */ |
| public Boolean isProvidedPort(Port pt, String stName) { |
| Stereotype st = pt.getAppliedStereotype(stName); |
| ClientServerPort csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| if (csp != null) |
| return csp.getKind().equals(ClientServerKind.PROVIDED); |
| else |
| return false; |
| |
| } |
| |
| /** |
| * Checks if a specific port is a ClientServerPort which can require interfaces. |
| * |
| * @param pt the port |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return true if the port is a ClientServerPort of kind REQUIRED, false otherwise |
| */ |
| public Boolean isRequiredPort(Port pt, String stName) { |
| Stereotype st = pt.getAppliedStereotype(stName); |
| ClientServerPort csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| if (csp != null) |
| return csp.getKind().equals(ClientServerKind.REQUIRED); |
| else |
| return false; |
| } |
| |
| /** |
| * Gets the list of the provided interfaces from a list of ClientServerPorts. |
| * |
| * @param portList the list of ports. |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return a list containing the provided interfaces. |
| */ |
| public List<Interface> getProvidedInterfaceList(List<Port> portList, String stName) { |
| |
| ArrayList<Interface> intList = new ArrayList<Interface>(); |
| Port pt = null; |
| Stereotype st = null; |
| ClientServerPort csp = null; |
| |
| for (int i=0; i <portList.size(); i++) { |
| pt = portList.get(i); |
| st = pt.getAppliedStereotype(stName); |
| csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| |
| if (csp!= null && csp.getKind().equals(ClientServerKind.PROVIDED)) { |
| // Assumption: only 1 providedInterface x Port |
| intList.add(csp.getProvInterface().get(0)); |
| } |
| } |
| |
| return intList; |
| } |
| |
| /** |
| * Returns a String representing the names of the provided interfaces from a list of ClientServerPorts. |
| * |
| * @param portList the list of ports. |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return the String representing the names of the provided interfaces |
| */ |
| public String getProvidedInterfaceListAsQualifiedString(List<Port> portList, String stName) { |
| |
| Port pt = null; |
| Stereotype st = null; |
| ClientServerPort csp = null; |
| String piNameList = new String(); |
| String interfaceName = null; |
| boolean firstWritten = false; |
| |
| for (int i=0; i <portList.size(); i++) { |
| pt = portList.get(i); |
| st = pt.getAppliedStereotype(stName); |
| csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| |
| if (csp != null && csp.getKind().equals(ClientServerKind.PROVIDED)) { |
| // Assumption: only 1 providedInterface x Port |
| interfaceName = csp.getProvInterface().get(0).getName(); |
| if (! firstWritten) { |
| piNameList += interfaceName + "." + interfaceName; |
| firstWritten = true; |
| } else { |
| piNameList += " and " + interfaceName + "." + interfaceName; |
| } |
| } |
| } |
| |
| return piNameList; |
| } |
| |
| /** |
| * Checks if among the elements of a List of ClientServerPort, at least one can require ports. |
| * |
| * @param portList the list of ports. |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return true if a ClientServerPort of kind REQUIRED is found in the list, false otherwise. |
| */ |
| public Boolean hasRequiredInterface(List<Port> portList, String stName) { |
| Port pt = null; |
| Stereotype st = null; |
| ClientServerPort csp = null; |
| |
| for (int i=0; i <portList.size(); i++) { |
| pt = portList.get(i); |
| st = pt.getAppliedStereotype(stName); |
| csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| |
| if (csp!= null && csp.getKind().equals(ClientServerKind.REQUIRED)) { |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| /** |
| * Gets the list of the required interfaces from a list of ClientServerPorts. |
| * |
| * @param portList the list of ports. |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return a list containing the required interfaces. |
| */ |
| public List<Interface> getRequiredInterfaceList(List<Port> portList, String stName) { |
| |
| ArrayList<Interface> intList = new ArrayList<Interface>(); |
| Port pt = null; |
| Stereotype st = null; |
| ClientServerPort csp = null; |
| |
| for (int i=0; i <portList.size(); i++) { |
| pt = portList.get(i); |
| st = pt.getAppliedStereotype(stName); |
| csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| |
| if (csp != null && csp.getKind().equals(ClientServerKind.REQUIRED)) { |
| // Assumption: only 1 requiredInterface x Port |
| intList.add(csp.getReqInterface().get(0)); |
| } |
| } |
| |
| return intList; |
| } |
| |
| /** |
| * Gets a String representing the operation signature. |
| * |
| * @param c the component containing the operation |
| * @param op the operation |
| * @return the operation signature as a String |
| */ |
| public String getOperationSignature(Component c, Operation op) { |
| String opName = new String(c.getName() + "." + op.getName()); |
| //MODIFIED MP WAS ELIST |
| List<Parameter> lParam = op.getOwnedParameters(); |
| if (lParam.size() > 0) { |
| opName += "("; |
| opName += lParam.get(0).getType().getName(); |
| |
| if (lParam.size() > 1) { |
| |
| for (int i=1; i < lParam.size(); i++) { |
| opName += ", " + lParam.get(i).getType().getName(); |
| } |
| } |
| opName += ")"; |
| } |
| return opName; |
| } |
| |
| /** |
| * This is a method very specific to the Acceleo transformation (Ada code generation) |
| * |
| * @param slotList the slot list |
| * @param stName the st name |
| * @param st2Name the st2 name |
| * @return the package to with spec |
| */ |
| public List<String> getPackageToWithSpec(List<Object> slotList, String stName, String st2Name) { |
| |
| boolean cyclicRequired = false; |
| boolean sporadicRequired = false; |
| |
| boolean pkgSystemAdded = false; |
| boolean pkgRealTimeAdded = false; |
| boolean pkgDataStructureAdded = false; |
| boolean pkgContainerProtectionAdded = false; |
| boolean pkgCyclicTaskAdded = false; |
| |
| Slot slot = null; |
| CHRtPortSlot chrtPs = null; |
| CHRtSpecification chrtSpec = null; |
| List<CHRtSpecification> chRtSpecList = null; |
| ArrayList<String> withPackageList = new ArrayList<String>(); |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| chRtSpecList = chrtPs.getCH_RtSpecification(); |
| |
| for (int j=0; j < chRtSpecList.size(); j++) { |
| chrtSpec = chRtSpecList.get(j); |
| String occKind = chrtSpec.getOccKind(); |
| |
| if (occKind != null && ! occKind.equals("")) { |
| |
| if (occKind.startsWith("periodic") && ! cyclicRequired) { |
| |
| if (! pkgRealTimeAdded) { |
| withPackageList.add("with Ada.Real_Time; use Ada.Real_Time;"); |
| pkgRealTimeAdded = true; |
| } |
| |
| if (! pkgDataStructureAdded) { |
| withPackageList.add("with Data_Structure;"); |
| pkgDataStructureAdded = true; |
| } |
| |
| if (! pkgContainerProtectionAdded) { |
| withPackageList.add("with Container_Protection; use Container_Protection;"); |
| pkgContainerProtectionAdded = true; |
| } |
| |
| if (!pkgCyclicTaskAdded) { |
| String withCyclicTask = "with Cyclic_Task;"; |
| if (isMonitored(slot)) |
| withCyclicTask = "with Cyclic_Task_Monitored;"; |
| withPackageList.add(withCyclicTask); |
| pkgCyclicTaskAdded = true; |
| } |
| |
| cyclicRequired = true; |
| } else if (occKind.startsWith("sporadic") && ! sporadicRequired) { |
| |
| if (! pkgSystemAdded) { |
| withPackageList.add("with System;"); |
| pkgSystemAdded = true; |
| } |
| |
| if (! pkgRealTimeAdded) { |
| withPackageList.add("with Ada.Real_Time; use Ada.Real_Time;"); |
| pkgRealTimeAdded = true; |
| } |
| |
| if (! pkgDataStructureAdded) { |
| withPackageList.add("with Data_Structure;"); |
| pkgDataStructureAdded = true; |
| } |
| |
| sporadicRequired = true; |
| } |
| |
| } else if (chrtSpec.getProtection().equals(CallConcurrencyKind.GUARDED)) {// occKind is null or "" |
| |
| if (! pkgSystemAdded) { |
| withPackageList.add("with System;"); |
| pkgSystemAdded = true; |
| } |
| |
| } |
| } |
| |
| if (cyclicRequired && sporadicRequired) { |
| break; |
| } |
| } |
| } |
| return withPackageList; |
| } |
| |
| /** |
| * Gets the "value" substring of a given VSL string. |
| * For example, from the VSL String (value=45.0,unit=ms) this method returns 45.0 |
| * |
| * @param inputVSL the input VSL string |
| * @return the "value" substring |
| */ |
| public String getValue(String inputVSL) { |
| int endOfValueIndex = inputVSL.indexOf(",unit"); |
| int startOfValueIndex = inputVSL.indexOf("value=") + 6; |
| return inputVSL.substring(startOfValueIndex, endOfValueIndex); |
| } |
| |
| /** |
| * Gets the "unit" substring of a given VSL string. |
| * For example, from the VSL String (value=45.0,unit=ms) this method returns ms |
| * |
| * @param inputVSL the input VSL string |
| * @return the "unit" substring |
| */ |
| public String getUnit(String inputVSL) { |
| int startOfUnitIndex = inputVSL.indexOf("unit=") + 5; |
| int endOfUnitIndex = inputVSL.indexOf("))"); |
| return inputVSL.substring(startOfUnitIndex, endOfUnitIndex); |
| } |
| |
| /** |
| * Gets the Priority of an operation. |
| * Pre-condition : op is an operation marked as "cyclic" in some CHRtSpecification |
| * |
| * @param slotList the list of Slots in the model |
| * @param op the Operation |
| * @param stName unused |
| * @return the priority as String, or a message error |
| */ |
| public String getPriority(List<Object> slotList, Operation op, String stName) { |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| CHRtPortSlot chrtPs = null; |
| |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| if (CHRtSpecList.get(j).getContext().equals(op)) { |
| return CHRtSpecList.get(j).getRelativePriority(); |
| } |
| } |
| } |
| |
| } |
| // |
| return "ERROR_PRIORITY_NOT_FOUND"; |
| } |
| |
| /** |
| * Gets the Period or minimum interarrival time (MIAT) of an operation. |
| * Pre-condition : op is an operation marked as "cyclic" or "sporadic" in some CHRtSpecification |
| * |
| * @param slotList the list of Slots in the model |
| * @param op the Operation |
| * @param stName unused |
| * @return the period (for a "cyclic" operation) or the MIAT (for a "sporadic" operation) |
| */ |
| public String getPeriodOrMIAT(List<Object> slotList, Operation op, String stName) { |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| CHRtPortSlot chrtPs = null; |
| |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| if (CHRtSpecList.get(j).getContext().equals(op)) { |
| |
| String occKind = chrtPs.getCH_RtSpecification().get(0).getOccKind(); |
| String periodOrMIAT = getValue(occKind); |
| if (periodOrMIAT.length() <= 5) { |
| return periodOrMIAT.substring(0, periodOrMIAT.length()-2); |
| } else { |
| return periodOrMIAT.substring(0, periodOrMIAT.length()-5).concat("_"). |
| concat(periodOrMIAT.substring(periodOrMIAT.length()-5, periodOrMIAT.length()-2)); |
| } |
| } |
| } |
| } |
| } |
| return "ERROR_PERIOD_OR_MIAT_NOT_FOUND"; |
| } |
| |
| /** |
| * Gets the Ceiling of an operation. |
| * Pre-condition : op is an operation marked as "cyclic", "sporadic" or "protected" in some CHRtSpecification |
| * |
| * @param slotList the list of Slots in the model |
| * @param op the Operation |
| * @param stName unused |
| * @return the Ceiling as String, or a message error |
| */ |
| public String getCeiling(List<Object> slotList, Operation op, String stName) { |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| CHRtPortSlot chrtPs = null; |
| |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| if (CHRtSpecList.get(j).getContext().equals(op)) { |
| |
| return chrtPs.getCH_RtSpecification().get(j).getCeiling(); |
| } |
| } |
| } |
| } |
| return "ERROR_CEILING_NOT_FOUND"; |
| } |
| |
| /** |
| * Gets a list of cyclic operations from a list of slots. |
| * |
| * @param slotList the list of Slots in the model |
| * @param stName unused |
| * @return a list containing the cyclic operations |
| */ |
| public List<Operation> getCyclicOperationList(List<Slot> slotList, String stName) { |
| |
| ArrayList<Operation> cyclicOpList = new ArrayList<Operation>(); |
| CHRtPortSlot chrtPs = null; |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| String occKind = chrtPs.getCH_RtSpecification().get(j).getOccKind(); |
| |
| if (occKind != null) { |
| if (occKind.startsWith("periodic")) { |
| cyclicOpList.add((Operation) CHRtSpecList.get(j).getContext()); |
| } |
| } |
| } |
| } |
| } |
| return cyclicOpList; |
| } |
| |
| |
| //TODO it has to be modified after INTECS adds the stereotype for monitoring |
| public boolean isMonitored(List<Object> slotList, Operation op, String stName) { |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| CHRtPortSlot chrtPs = null; |
| |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| if (CHRtSpecList.get(j).getContext().equals(op)) { |
| |
| return isMonitored(slot); |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| public String getMonitoredTaskName(List<Object> slotList, Operation op, String stName) { |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| CHRtPortSlot chrtPs = null; |
| |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| CHRtSpecification chRtSpecification = CHRtSpecList.get(j); |
| if (chRtSpecification.getContext().equals(op)) { |
| |
| return chrtPs.getBase_Slot().getOwningInstance().getName() + "_" |
| + chrtPs.getBase_Slot().getDefiningFeature().getName() |
| + "_" + chRtSpecification.getContext().getName(); |
| } |
| } |
| } |
| } |
| return "INVALID"; |
| } |
| |
| //TODO it has to be modified after INTECS adds the stereotype for monitoring |
| public boolean isMonitored(Slot op) { |
| return true; |
| } |
| |
| /** |
| * Gets a list of sporadic operations from a list of slots. |
| * |
| * @param slotList the list of Slots in the model |
| * @param stName unused |
| * @return a list containing the sporadic operations |
| */ |
| public List<Operation> getSporadicOperationList(List<Slot> slotList, String stName) { |
| |
| ArrayList<Operation> sporadicOpList = new ArrayList<Operation>(); |
| CHRtPortSlot chrtPs = null; |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| String occKind = chrtPs.getCH_RtSpecification().get(j).getOccKind(); |
| |
| if (occKind != null) { |
| if (occKind.startsWith("sporadic")) { |
| sporadicOpList.add((Operation) CHRtSpecList.get(j).getContext()); |
| } |
| } |
| } |
| } |
| } |
| return sporadicOpList; |
| } |
| |
| /** |
| * Gets a list of protected operations from a list of slots. |
| * |
| * @param slotList the list of Slots in the model |
| * @param stName unused |
| * @return a list containing the protected operations |
| */ |
| public List<Operation> getProtectedOperationList(List<Slot> slotList, String stName) { |
| |
| ArrayList<Operation> protectedOpList = new ArrayList<Operation>(); |
| CHRtPortSlot chrtPs = null; |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| String occKind = chrtPs.getCH_RtSpecification().get(j).getOccKind(); |
| |
| // Sporadic kind is GUARDED and occKind => sporadic(...) |
| if (CHRtSpecList.get(j).getProtection().equals(CallConcurrencyKind.GUARDED) && |
| (occKind == null || occKind.isEmpty())) { |
| protectedOpList.add((Operation) CHRtSpecList.get(j).getContext()); |
| } |
| } |
| } |
| } |
| return protectedOpList; |
| } |
| |
| |
| /** |
| * Gets the Protected Operation from the given Slot |
| * |
| * @param sl the Slot |
| * @param stName unused |
| * @return the Protected Operation |
| */ |
| public List<Operation> getSlotProtectedOperation(Slot sl, String stName) { |
| |
| ArrayList<Operation> protectedOpList = new ArrayList<Operation>(); |
| CHRtPortSlot chrtPs = null; |
| |
| List<Stereotype> stList = sl.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) sl.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| String occKind = chrtPs.getCH_RtSpecification().get(j).getOccKind(); |
| |
| // Sporadic kind is GUARDED and occKind => sporadic(...) |
| if (CHRtSpecList.get(j).getProtection().equals(CallConcurrencyKind.GUARDED) && |
| (occKind == null || occKind.isEmpty())) { |
| protectedOpList.add((Operation) CHRtSpecList.get(j).getContext()); |
| } |
| } |
| } |
| return protectedOpList; |
| } |
| |
| |
| /** |
| * Gets a list of unprotected operations from a list of slots. |
| * |
| * @param slotList the list of Slots in the model |
| * @param stName unused |
| * @return a list containing the unprotected operations |
| */ |
| public List<Operation> getUnprotectedOperationList(List<Slot> slotList, String stName) { |
| |
| ArrayList<Operation> unprotectedOpList = new ArrayList<Operation>(); |
| CHRtPortSlot chrtPs = null; |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| String occKind = chrtPs.getCH_RtSpecification().get(j).getOccKind(); |
| if (CHRtSpecList.get(j).getProtection().equals(CallConcurrencyKind.CONCURRENT) && |
| (occKind == null || occKind.isEmpty())) { |
| unprotectedOpList.add((Operation) CHRtSpecList.get(j).getContext()); |
| } |
| } |
| } |
| } |
| return unprotectedOpList; |
| } |
| |
| /** |
| * Gets the list of component instances from the list of the instances with multiplicity. (i.e package "_full" in the model) |
| * |
| * @param instList the list of the instances with multiplicity |
| * @param stName the name of the stereotype. Must be "CHESS::ComponentModel::ComponentImplementation" |
| * @return the list of the component instances |
| */ |
| public List<InstanceSpecification> getComponentInstanceList(List<InstanceSpecification> instList, String stName) { |
| ArrayList<InstanceSpecification> componentInstanceList = new ArrayList<InstanceSpecification>(); |
| |
| for (int i=0; i<instList.size(); i++) { |
| List<Classifier> clList = instList.get(i).getClassifiers(); |
| |
| if (clList.size() > 0) { |
| Stereotype st = clList.get(0).getAppliedStereotype(stName); |
| |
| if (st != null && !instList.get(i).getNearestPackage().getName().endsWith("_full")) { |
| componentInstanceList.add(instList.get(i)); |
| } |
| } |
| } |
| |
| return componentInstanceList; |
| } |
| |
| /** |
| * Gets the list of slots that require an interface from a list of instances |
| * |
| * @param instList the list of instances |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return the list of slots that require an interface |
| */ |
| public List<Slot> getRequiredInterfaceSlotList(List<InstanceSpecification> instList, String stName) { |
| ArrayList<Slot> reqInterfaceSlotList = new ArrayList<Slot>(); |
| |
| for (int i=0; i<instList.size(); i++) { |
| List<Slot> slList = instList.get(i).getSlots(); |
| for (int j=0; j<slList.size(); j++) { |
| |
| if (slList.get(j).getDefiningFeature() instanceof Port) { |
| Port pt = (Port) slList.get(j).getDefiningFeature(); |
| Stereotype st = pt.getAppliedStereotype(stName); |
| if (st != null) { |
| ClientServerPort csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| if (csp.getKind() == ClientServerKind.REQUIRED) { |
| reqInterfaceSlotList.add(slList.get(j)); |
| } |
| } |
| } |
| } |
| } |
| |
| // the list of all RI |
| return reqInterfaceSlotList; |
| } |
| |
| |
| /** |
| * Gets the list of slots that require an interface from a single instance |
| * |
| * @param instList the InstanceSpecfication |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return the list of slots that require an interface |
| */ |
| public List<Slot> getInstanceRequiredInterfaceSlotList(InstanceSpecification inst, String stName) { |
| ArrayList<Slot> reqInterfaceSlotList = new ArrayList<Slot>(); |
| |
| |
| List<Slot> slList = inst.getSlots(); |
| for (int j=0; j<slList.size(); j++) { |
| |
| if (slList.get(j).getDefiningFeature() instanceof Port) { |
| Port pt = (Port) slList.get(j).getDefiningFeature(); |
| Stereotype st = pt.getAppliedStereotype(stName); |
| if (st != null) { |
| ClientServerPort csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| if (csp.getKind() == ClientServerKind.REQUIRED) { |
| reqInterfaceSlotList.add(slList.get(j)); |
| } |
| } |
| } |
| } |
| |
| // the list of all RI slots of the instance specification |
| return reqInterfaceSlotList; |
| } |
| |
| /** |
| * Gets the list of slots that provide an interface from a list of instances |
| * |
| * @param instList the list of instances |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return the list of slots that provide an interface |
| */ |
| public List<Slot> getProvidedInterfaceSlotList(List<InstanceSpecification> instList, String stName) { |
| ArrayList<Slot> provInterfaceSlotList = new ArrayList<Slot>(); |
| |
| for (int i=0; i<instList.size(); i++) { |
| List<Slot> slList = instList.get(i).getSlots(); |
| for (int j=0; j<slList.size(); j++) { |
| |
| if (slList.get(j).getDefiningFeature() instanceof Port) { |
| Port pt = (Port) slList.get(j).getDefiningFeature(); |
| Stereotype st = pt.getAppliedStereotype(stName); |
| if (st != null) { |
| ClientServerPort csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| if (csp.getKind() == ClientServerKind.PROVIDED) { |
| provInterfaceSlotList.add(slList.get(j)); |
| } |
| } |
| } |
| } |
| } |
| |
| // the list of all RI |
| return provInterfaceSlotList; |
| } |
| |
| |
| /** |
| * Gets the list of slots that provide an interface from a single instance |
| * |
| * @param instList the InstanceSpecfication |
| * @param stName the stereotype name. Must be "MARTE::MARTE_DesignModel::GCM::ClientServerPort" |
| * @return the list of slots that provide an interface |
| */ |
| public List<Slot> getInstanceProvidedInterfaceSlotList(InstanceSpecification inst, String stName) { |
| ArrayList<Slot> provInterfaceSlotList = new ArrayList<Slot>(); |
| |
| |
| List<Slot> slList = inst.getSlots(); |
| for (int j=0; j<slList.size(); j++) { |
| |
| if (slList.get(j).getDefiningFeature() instanceof Port) { |
| Port pt = (Port) slList.get(j).getDefiningFeature(); |
| Stereotype st = pt.getAppliedStereotype(stName); |
| if (st != null) { |
| ClientServerPort csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| if (csp.getKind() == ClientServerKind.PROVIDED) { |
| provInterfaceSlotList.add(slList.get(j)); |
| } |
| } |
| } |
| } |
| |
| // the list of all RI slots of the instance specification |
| return provInterfaceSlotList; |
| } |
| |
| |
| |
| /** |
| * Gets the connector inst list. |
| * |
| * @param instList the inst list |
| * @param stName the st name |
| * @return the connector inst list |
| */ |
| public List<InstanceSpecification> getConnectorInstList(List<InstanceSpecification> instList, String stName) { |
| ArrayList<InstanceSpecification> connectorInstList = new ArrayList<InstanceSpecification>(); |
| |
| for (int i=0; i<instList.size(); i++) { |
| if (instList.get(i).getClassifiers().size()==0) { |
| List<Slot> slList = instList.get(i).getSlots(); |
| if (slList.size() > 0) { |
| Port pt = (Port) slList.get(0).getDefiningFeature(); |
| Stereotype st = pt.getAppliedStereotype(stName); |
| // check if the defining feature is a <<ClientServerPort>> |
| if (st != null) { |
| connectorInstList.add(instList.get(i)); |
| } |
| } |
| } |
| } |
| return connectorInstList; |
| } |
| |
| |
| |
| /** |
| * Gets the component impl list. |
| * |
| * @param compList the comp list |
| * @param stName the st name |
| * @return the component impl list |
| */ |
| public List<Component> getComponentImplList(List<Component> compList, String stName) { |
| ArrayList<Component> compImplList = new ArrayList<Component>(); |
| |
| for (int i=0; i<compList.size(); i++) { |
| Stereotype st = compList.get(i).getAppliedStereotype(stName); |
| // check if it is a <<ComponentImplementation>> |
| if (st != null) { |
| compImplList.add(compList.get(i)); |
| } |
| } |
| return compImplList; |
| } |
| |
| /** |
| * Gets the provided slot bounded to the given slot |
| * |
| * @param sl the given slot |
| * @param connectorInstList the list of connector instances |
| * @return the bounded provided slot |
| */ |
| public Slot getBoundPIslot(Slot sl, List<InstanceSpecification> connectorInstList) { |
| |
| // All methods based on equality between slot fail (indexOf, contains, etc..) |
| // Check that definingFeature and owningInstance of the slot are matching |
| |
| for (int i=0; i<connectorInstList.size(); i++) { |
| List<Slot> slotList = connectorInstList.get(i).getSlots(); |
| List<Slot> targetInstanceSlotList = null; |
| Slot targetSlot = null; |
| |
| // 2 slots are included in the instance of the connecto. |
| Slot slot0 = slotList.get(0); |
| Slot slot1 = slotList.get(1); |
| |
| if (slot0.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot0.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| //slot1 is the slot in the instance of the connector |
| //we must return the slot in the instance of the component instance! |
| vsList = slot1.getValues(); |
| iv = (InstanceValue) vsList.get(0); |
| InstanceSpecification targetIs = iv.getInstance(); |
| targetInstanceSlotList = targetIs.getSlots(); |
| for (int j = 0; j < targetInstanceSlotList.size(); j++) { |
| targetSlot = targetInstanceSlotList.get(j); |
| if (targetSlot.getDefiningFeature().equals(slot1.getDefiningFeature())) { |
| return targetSlot; |
| } |
| } |
| |
| } |
| } else if (slot1.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot1.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| //slot0 is the slot in the instance of the connector |
| //we must return the slot in the instance of the component instance! |
| vsList = slot0.getValues(); |
| iv = (InstanceValue) vsList.get(0); |
| InstanceSpecification targetIs = iv.getInstance(); |
| targetInstanceSlotList = targetIs.getSlots(); |
| for (int j = 0; j < targetInstanceSlotList.size(); j++) { |
| targetSlot = targetInstanceSlotList.get(j); |
| if (targetSlot.getDefiningFeature().equals(slot0.getDefiningFeature())) { |
| return targetSlot; |
| } |
| } |
| |
| } |
| } |
| } |
| return sl; |
| } |
| |
| /** |
| * Gets the required slots bounded to the given slot |
| * |
| * @param sl the given slot |
| * @param connectorInstList the list of connector instances |
| * @return the bounded required slots list |
| */ |
| public List<Slot> getBoundRIslotList(Slot sl, List<InstanceSpecification> connectorInstList) { |
| List<Slot> boundRIslotList = new ArrayList<Slot>(); |
| |
| // Check that definingFeature and owningInstance of the slot are matching |
| |
| for (int i=0; i<connectorInstList.size(); i++) { |
| List<Slot> slotList = connectorInstList.get(i).getSlots(); |
| List<Slot> targetInstanceSlotList = null; |
| Slot targetSlot = null; |
| |
| // 2 slots are included in the instance of the connector. |
| Slot slot0 = slotList.get(0); |
| Slot slot1 = slotList.get(1); |
| |
| if (slot0.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot0.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| //slot1 is the slot in the instance of the connector |
| //we must return the corresponding slot in the instance of the component instance! |
| vsList = slot1.getValues(); |
| iv = (InstanceValue) vsList.get(0); |
| InstanceSpecification targetIs = iv.getInstance(); |
| targetInstanceSlotList = targetIs.getSlots(); |
| for (int j = 0; j < targetInstanceSlotList.size(); j++) { |
| targetSlot = targetInstanceSlotList.get(j); |
| if (targetSlot.getDefiningFeature().equals(slot1.getDefiningFeature())) { |
| boundRIslotList.add(targetSlot); |
| } |
| } |
| |
| } |
| } else if (slot1.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot1.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| //slot0 is the slot in the instance of the connector |
| //we must return the corresponding slot in the instance of the component instance! |
| vsList = slot0.getValues(); |
| iv = (InstanceValue) vsList.get(0); |
| InstanceSpecification targetIs = iv.getInstance(); |
| targetInstanceSlotList = targetIs.getSlots(); |
| for (int j = 0; j < targetInstanceSlotList.size(); j++) { |
| targetSlot = targetInstanceSlotList.get(j); |
| if (targetSlot.getDefiningFeature().equals(slot0.getDefiningFeature())) { |
| boundRIslotList.add(targetSlot); |
| } |
| } |
| |
| } |
| } |
| } |
| return boundRIslotList; |
| } |
| |
| /** |
| * Checks if the given operation is cyclic |
| * |
| * @param slotList the list of slots in the model |
| * @param op the operation |
| * @param stName unused |
| * @return true, if the operation cyclic |
| */ |
| public boolean isCyclicOperation(List<Slot> slotList, Operation op, String stName) { |
| |
| CHRtPortSlot chrtPs = null; |
| Slot slot = null; |
| |
| for (int i=0; i < slotList.size(); i++) { |
| slot = (Slot) slotList.get(i); |
| List<Stereotype> stList = slot.getAppliedStereotypes(); |
| if (! stList.isEmpty()) { |
| chrtPs = (CHRtPortSlot) slot.getStereotypeApplication(stList.get(0)); |
| List<CHRtSpecification> CHRtSpecList = chrtPs.getCH_RtSpecification(); |
| for (int j=0; j < CHRtSpecList.size(); j++) { |
| Operation myOp = (Operation) CHRtSpecList.get(j).getContext(); |
| |
| if (myOp.equals(op)) { |
| String occKind = chrtPs.getCH_RtSpecification().get(j).getOccKind(); |
| |
| if (occKind != null) { |
| if (occKind.startsWith("periodic")) { |
| return true; |
| } |
| } |
| } |
| } |
| } |
| } |
| return false; |
| } |
| |
| |
| /** |
| * Gets the list of operations called by the given operation. |
| * |
| * @param op the given operation |
| * @return the list of called operations |
| */ |
| public List<CallOperationAction> getCalledOperation(Operation op) { |
| ArrayList<CallOperationAction> coaList = new ArrayList<CallOperationAction>(); |
| List<Behavior> bhList = op.getMethods(); |
| |
| if (bhList.size() > 0) { |
| for (int i=0; i < bhList.size(); i++) { |
| if (bhList.get(i) instanceof Activity) { |
| |
| List<ActivityNode> actNodeList = ((Activity) bhList.get(i)).getNodes(); |
| for (int j=0; j < actNodeList.size(); j++) { |
| if (actNodeList.get(j) instanceof CallOperationAction) { |
| coaList.add((CallOperationAction) actNodeList.get(j)); |
| } |
| } |
| } |
| } |
| } |
| return coaList; |
| } |
| |
| /** |
| * Checks if two operation are equal to each other according to the following criteria: |
| * name, visibility, size of parameter list |
| * type of parameters, name of parameters |
| * isAbstract is purposely not considered |
| * |
| * @param op1 the first operation |
| * @param op2 the second operation |
| * @return true, two operation are equal to each other |
| */ |
| public boolean isSameOperation(Operation op1, Operation op2) { |
| if (! op1.getName().equals(op2.getName())) { |
| return false; |
| } |
| |
| if (! op1.getVisibility().equals(op2.getVisibility())) { |
| return false; |
| } |
| |
| |
| List<Parameter> paramList1 = op1.getOwnedParameters(); |
| List<Parameter> paramList2 = op2.getOwnedParameters(); |
| |
| if (paramList1.size() != paramList2.size()) { |
| return false; |
| } |
| |
| for (int i = 0; i < paramList1.size(); i++) { |
| Parameter par1 = paramList1.get(i); |
| Parameter par2 = paramList2.get(i); |
| |
| //par1.getType().equals(par2.getType()) unexpectedly fails |
| //replacing it with a very reliable check on names |
| if (! par1.getType().getName().equals(par2.getType().getName())) { |
| return false; |
| } |
| |
| if (! par1.getName().equals(par2.getName())) { |
| return false; |
| } |
| |
| if (! par1.getDirection().equals(par2.getDirection())) { |
| return false; |
| } |
| } |
| return true; |
| } |
| |
| |
| /** |
| * Gets the interface containing the given operation searching in the list of provided interfaces |
| * |
| * @param op the given operation |
| * @param ptList the list of ports. Used to get the list of provided interfaces |
| * @param stName the stereotype name |
| * @return the interface containing the given operation |
| */ |
| public Interface getInterface(Operation op, List<Port> ptList, String stName) { |
| |
| List<Interface> interfaceList = getProvidedInterfaceList(ptList, stName); |
| |
| for (int i=0; i < interfaceList.size(); i++) { |
| Interface myIf = interfaceList.get(i); |
| List<Operation> opList = myIf.getOperations(); |
| |
| for (int j=0; j < opList.size(); j++) { |
| if ( isSameOperation(op, opList.get(j))) { |
| return myIf; |
| } |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Checks if is data type with required. |
| * Checks if the generated code requires a "with DataTypes;" clause |
| * |
| * @param aInt the Interface |
| * @return true, if "with DataTypes;" clause is required |
| */ |
| public boolean isDataTypeWithRequired(Interface aInt) { |
| List<Operation> opList = aInt.getOwnedOperations(); |
| for (int i=0; i < opList.size(); i++) { |
| List<Parameter> parList = opList.get(i).getOwnedParameters(); |
| |
| for (int j=0; j < parList.size(); j++) { |
| Parameter par = parList.get(j); |
| if (! (par.getName().equals("Integer") || par.getName().equals("Float") || |
| par.getName().equals("Natural") )) { |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Gets the implementation language from a given ComponentImplementation. |
| * |
| * @param c the given ComponentImplementation |
| * @param stName the stereotype name |
| * @return the implementation language String |
| */ |
| public String getImplementationLanguage(Component c, String stName) { |
| Stereotype cImplSt = c.getAppliedStereotype(stName); |
| ComponentImplementation cImpl = (ComponentImplementation) c.getStereotypeApplication(cImplSt); |
| |
| String lang = cImpl.getLanguage(); |
| if (lang == null) { |
| return "Ada"; |
| } else { |
| return lang; |
| } |
| } |
| |
| /** |
| * Converts, if possible, an Ada data type to a C data type. |
| * |
| * @param type the Ada type |
| * @return the C type as String |
| */ |
| public String adaTypeToCtype(Type type) { |
| if (type instanceof PrimitiveType && type.getName().equals("Integer")) { |
| return "int"; |
| } else if (type instanceof PrimitiveType && type.getName().equals("Float")) { |
| return "float"; |
| } else if (type instanceof PrimitiveType && type.getName().equals("Boolean")) { |
| return "bool"; |
| } //else if (type instanceof Enumeration) { |
| // return "int"; |
| //} |
| |
| // assumes that the datatype have been defined in the datatype package |
| return type.getName(); |
| } |
| |
| /** |
| * Checks if there is at least one ComponentImplementation with language equals to C or C++ |
| * |
| * @param lComp the list of ComponentImplementation |
| * @param stName the stereotype name |
| * @return true if there is at least one ComponentImplementation with language equals to C or C++ |
| */ |
| public Boolean hasCimplementation(List<Component> lComp, String stName) { |
| for (int i=0; i < lComp.size(); i++) { |
| Stereotype compImplSt = lComp.get(i).getAppliedStereotype(stName); |
| if (compImplSt != null) { |
| ComponentImplementation cImpl = (ComponentImplementation) lComp.get(i).getStereotypeApplication(compImplSt); |
| if (cImpl.getLanguage().equals("C") || (cImpl.getLanguage().equals("C++"))) { |
| return true; |
| } |
| } |
| } |
| // all component implementations are realized in Ada |
| return false; |
| } |
| |
| /** |
| * Gets the list of called operation (CalledOperationAction) from the given Activity. |
| * |
| * @param act the Activity |
| * @return the list of called operations |
| */ |
| public List<CallOperationAction> getCalledOperationList(Activity act) { |
| ArrayList<CallOperationAction> coaList = new ArrayList<CallOperationAction>(); |
| |
| List<ActivityNode> actNodeList = act.getNodes(); |
| ActivityNode actNode = null; |
| ControlFlow cf = null; |
| boolean finalNodeFound = false; |
| |
| for (int j=0; j < actNodeList.size(); j++) { |
| if (actNodeList.get(j) instanceof InitialNode) { |
| actNode = (InitialNode) actNodeList.get(j); |
| break; |
| } |
| } |
| // iNode contains the initial node of a well-specified activity diagram |
| while (! finalNodeFound) { |
| cf = (ControlFlow) actNode.getOutgoings().get(0); |
| if (cf.getTarget() instanceof CallOperationAction) { |
| actNode = (CallOperationAction) cf.getTarget(); |
| coaList.add((CallOperationAction) actNode); |
| } else if (cf.getTarget() instanceof ActivityFinalNode){ |
| finalNodeFound = true; |
| } else { |
| return null; |
| } |
| } |
| |
| return coaList; |
| } |
| |
| /** |
| * Gets the the Intra-Component Binding (ICB) Activity of the given Operation |
| * |
| * @param op the operation |
| * @return the ICB Activity |
| */ |
| public Activity getICB(Operation op) { |
| List<Behavior> bhList = op.getMethods(); |
| for (int i=0; i<bhList.size(); i++) { |
| if (bhList.get(i) instanceof Activity) { |
| return (Activity) bhList.get(i); |
| } |
| } |
| |
| return null; |
| } |
| |
| /** |
| * Gets the component instance list. |
| * |
| * @param cImpl the c impl |
| * @param allIsList the all is list |
| * @return the component instance list |
| */ |
| public List<InstanceSpecification> getComponentInstanceList(Component cImpl, List<InstanceSpecification> allIsList) { |
| ArrayList<InstanceSpecification> isList = new ArrayList<InstanceSpecification>(); |
| |
| for (int i=0; i<allIsList.size(); i++) { |
| if (allIsList.get(i).getClassifiers().get(0).equals(cImpl)) { |
| isList.add(allIsList.get(i)); |
| } |
| } |
| |
| return isList; |
| } |
| |
| // Deployment related services |
| |
| |
| /** |
| * Checks if the system is single node. |
| * |
| * @param allIsList the list of all the instances |
| * @param stName the stereotype name |
| * @return true if the system is single node, false if it is multi node (distributed) |
| */ |
| public Boolean isSingleNodeSystem(List<InstanceSpecification> allIsList, String stName) { |
| InstanceSpecification processingNode = null; |
| Stereotype st = null; |
| |
| for (int i=0; i < allIsList.size(); i++) { |
| st = allIsList.get(i).getAppliedStereotype(stName); |
| |
| if (st != null) { |
| if (processingNode == null) { |
| processingNode = allIsList.get(i); |
| } else { |
| if (! allIsList.get(i).equals(processingNode)) { |
| return false; |
| } |
| } |
| } |
| } |
| |
| return true; |
| } |
| |
| |
| /** |
| * Gets the list of processing nodes. |
| * |
| * @param allIsList the list of all the instances |
| * @param stName the the stereotype name |
| * @return the list of processing nodes. |
| */ |
| public List<InstanceSpecification> getProcessingNodeList(List<InstanceSpecification> allIsList, String stName) { |
| ArrayList<InstanceSpecification> pnList = new ArrayList<InstanceSpecification>(); |
| Stereotype st = null; |
| |
| for (int i=0; i < allIsList.size(); i++) { |
| st = allIsList.get(i).getAppliedStereotype(stName); |
| |
| if (st != null) { |
| pnList.add(allIsList.get(i)); |
| } |
| } |
| |
| return pnList; |
| } |
| |
| /** |
| * Gets the instance specification deployed to the given instance specification hw node. |
| * |
| * @param node the given hw node |
| * @param commList the list of comments (assigns) |
| * @param stName the stereotype name |
| * @return list of instance specification deployed |
| */ |
| public List<InstanceSpecification> getNodeInstanceSpecification(InstanceSpecification node, List<Comment> commList, String stName) { |
| |
| ArrayList<InstanceSpecification> isList = new ArrayList<InstanceSpecification>(); |
| Stereotype st = null; |
| Assign ass = null; |
| |
| for (int i=0; i < commList.size(); i++) { |
| st = commList.get(i).getAppliedStereotype(stName); |
| |
| if (st != null) { |
| ass = (Assign) commList.get(i).getStereotypeApplication(st); |
| |
| if (ass.getTo().get(0).equals(node)) { |
| InstanceSpecification fromInst = (InstanceSpecification) ass.getFrom().get(0); |
| if(!isList.contains(fromInst)){ |
| isList.add(fromInst); |
| } |
| } |
| } |
| } |
| |
| return isList; |
| } |
| |
| /** |
| * Gets the list of component implementations from the given list of instance specifications. |
| * (it should be the list of deployed instances @see UML2Service.getNodeInstanceSpecification) |
| * |
| * @param isList the the list of instance specifications |
| * @param stName the stereotype name |
| * @return the list of component implementations |
| */ |
| public List<Component> getNodeComponentImplementationList(List<InstanceSpecification> isList, String stName) { |
| |
| ArrayList<Component> cImplList = new ArrayList<Component>(); |
| Component cImpl = null; |
| |
| for (int i=0; i < isList.size(); i++) { |
| |
| if (isList.get(i).getClassifiers().get(0) instanceof Component) { |
| cImpl = (Component) isList.get(i).getClassifiers().get(0); |
| if (cImpl.getAppliedStereotype(stName) != null) { |
| cImplList.add(cImpl); |
| } |
| |
| |
| } |
| } |
| |
| return cImplList; |
| } |
| |
| /** |
| * Gets the list of component types from the given list of component implementations |
| * |
| * @param cImplList the list of component implementations |
| * @param stName the stereotype name |
| * @return the list of component types |
| */ |
| public List<Component> getNodeComponentTypeList(List<Component> cImplList, String stName) { |
| |
| ArrayList<Component> cTypeList = new ArrayList<Component>(); |
| Component cType = null; |
| |
| for (int i=0; i < cImplList.size(); i++) { |
| |
| if (cImplList.get(i).getClientDependencies().get(0).getSuppliers().get(0) instanceof Component) { |
| cType = (Component) cImplList.get(i).getClientDependencies().get(0).getSuppliers().get(0); |
| if (cType.getAppliedStereotype(stName) != null) { |
| cTypeList.add(cType); |
| } |
| } |
| } |
| |
| return cTypeList; |
| } |
| |
| /** |
| * Gets the list of component types from the given list of component implementations |
| * |
| * @param cImplList the list of component implementations |
| * @param stName the stereotype name |
| * @return the list of component types |
| */ |
| public List<Component> getAllComponentTypeList(List<Component> allComponentList, String stName) { |
| |
| ArrayList<Component> cTypeList = new ArrayList<Component>(); |
| |
| for (int i=0; i < allComponentList.size(); i++) { |
| |
| if (allComponentList.get(i).getAppliedStereotype(stName) != null) { |
| cTypeList.add(allComponentList.get(i)); |
| } |
| } |
| |
| return cTypeList; |
| } |
| |
| /** |
| * Gets the list of interfaces from the given list of component types |
| * |
| * @param cImplList the list of component types |
| * @param stName the stereotype name |
| * @return the list of interfaces |
| */ |
| public List<Interface> getNodeInterfaceList(List<Component> cTypeList, String stName) { |
| |
| ArrayList<Interface> ifList = new ArrayList<Interface>(); |
| Stereotype st = null; |
| |
| for (int i=0; i < cTypeList.size(); i++) { |
| List<Property> pList = cTypeList.get(i).getOwnedAttributes(); |
| ClientServerPort csp = null; |
| |
| if (pList != null) { |
| |
| for (int j=0; j < pList.size(); j++) { |
| |
| if (pList.get(j) instanceof Port) { |
| st = pList.get(j).getAppliedStereotype(stName); |
| if (st != null) { |
| csp = (ClientServerPort) pList.get(j).getStereotypeApplication(st); |
| if (csp.getKind().equals(ClientServerKind.PROVIDED)) { |
| if (csp.getProvInterface().get(0) != null) { |
| ifList.add(csp.getProvInterface().get(0)); |
| } |
| } else if (csp.getKind().equals(ClientServerKind.REQUIRED)) { |
| if (csp.getReqInterface().get(0) != null) { |
| ifList.add(csp.getReqInterface().get(0)); |
| } |
| } |
| } |
| } |
| } |
| } |
| } |
| |
| return ifList; |
| } |
| |
| |
| /** |
| * Gets the deployment processing node. |
| * |
| * @param sl the given slot |
| * @param commList the list of comments (Assigns) |
| * @param stName the stereotype name |
| * @return the deployment processing node |
| */ |
| public InstanceSpecification getDeploymentProcessingNode(Slot sl, List<Comment> commList, String stName) { |
| |
| Stereotype st = null; |
| Assign assign = null; |
| |
| for (int i=0; i < commList.size(); i++) { |
| st = commList.get(i).getAppliedStereotype(stName); |
| |
| if (st != null) { |
| assign = (Assign) commList.get(i).getStereotypeApplication(st); |
| |
| if (assign.getFrom() != null && assign.getTo() != null) { |
| |
| if (assign.getTo().get(0) instanceof InstanceSpecification && |
| assign.getFrom().get(0) instanceof InstanceSpecification) { |
| if (assign.getFrom().get(0).equals(sl.getOwningInstance())) { |
| return (InstanceSpecification) assign.getTo().get(0); |
| } |
| } |
| } |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Checks if the remote communication is necessary. |
| * |
| * @param slList the list of slots |
| * @param procNode the processing node (@see UML2Service.getDeploymentProcessingNode) |
| * @param commList the list of comments |
| * @param stName the stereotype name |
| * @return true if remote communication is necessary, false otherwise |
| */ |
| public Boolean isRemoteCommNecessary (List<Slot> slList, InstanceSpecification procNode, |
| List<Comment> commList, String stName) { |
| |
| for (int i=0; i < slList.size(); i++) { |
| if (! this.getDeploymentProcessingNode(slList.get(i), commList, stName).equals(procNode)){ |
| return true; |
| } |
| } |
| |
| return false; |
| } |
| |
| /** |
| * Gets the provided operation list. |
| * |
| * @param cTypeList the list of component types |
| * @param stName the stereotype name |
| * @return the list of provided operations |
| */ |
| public List<Operation> getProvidedOperationList (List<Component> cTypeList, String stName) { |
| ArrayList<Operation> opList = new ArrayList<Operation>(); |
| Stereotype st = null; |
| Port pt = null; |
| Interface myIf = null; |
| |
| for (int i=0; i < cTypeList.size(); i++) { |
| List<Property> pList = cTypeList.get(i).getOwnedAttributes(); |
| |
| for (int j=0; j < pList.size(); j++) { |
| if (pList.get(j) instanceof Port) { |
| pt = (Port) pList.get(j); |
| st = pt.getAppliedStereotype(stName); |
| ClientServerPort csp = (ClientServerPort) pt.getStereotypeApplication(st); |
| if (csp == null) //flow-port case |
| continue; |
| if (csp.getKind().equals(ClientServerKind.PROVIDED)) { |
| myIf = csp.getProvInterface().get(0); |
| List<Operation> ifOpList = myIf.getOwnedOperations(); |
| for (int k=0; k < ifOpList.size(); k++) { |
| opList.add(ifOpList.get(k)); |
| } |
| } |
| } |
| } |
| } |
| |
| return opList; |
| } |
| |
| /** |
| * Gets the remote required slot list. |
| * |
| * @param riSlotList the required slot list |
| * @param procNode the processing node |
| * @param connectorInstList the connector instance list |
| * @param commList the list of comments |
| * @param assignStName the assign stereotype name |
| * @return the remote required slot list |
| */ |
| public List<Slot> getRemoteRIslotList(List<Slot> riSlotList, InstanceSpecification procNode, |
| List<InstanceSpecification> connectorInstList, List<Comment> commList, |
| String assignStName) { |
| |
| ArrayList<Slot> remoteRIslotList = new ArrayList<Slot>(); |
| Slot boundSlot = null; |
| |
| for (int i=0; i<riSlotList.size(); i++) { |
| boundSlot = getBoundPIslot(riSlotList.get(i), connectorInstList); |
| if (! getDeploymentProcessingNode(boundSlot, commList, assignStName).equals(procNode)) { |
| |
| if (! remoteRIslotList.contains(boundSlot)) { |
| remoteRIslotList.add(boundSlot); |
| } |
| } |
| } |
| |
| return remoteRIslotList; |
| } |
| |
| /** |
| * Checks if remote msg client is necessary. |
| * |
| * @param riSlotList the required slot list |
| * @param procNode the processing node |
| * @param connectorInstList the connector instance list |
| * @param commList the list of comments |
| * @param assignStName the assign stereotype name |
| * @return true if remote msg client is necessary, false otherwise |
| */ |
| public Boolean isRemoteMsgClientNecessary(List<Slot> riSlotList, InstanceSpecification procNode, |
| List<InstanceSpecification> connectorInstList, List<Comment> commList, String assignStName) { |
| |
| Slot boundSlot = null; |
| for (int i = 0; i < riSlotList.size(); i++) { |
| boundSlot = getBoundPIslot(riSlotList.get(i), connectorInstList); |
| if (!getDeploymentProcessingNode(boundSlot, commList, assignStName).equals(procNode)) { |
| return true; |
| } |
| } |
| // all RI slots are connected to PI of instances deployed on the same processor node |
| |
| return false; |
| } |
| |
| |
| /** |
| * Checks if remote msg server is necessary. |
| * |
| * @param slList the slot list |
| * @param procNode the processing node |
| * @param connectorInstList the connector instance list |
| * @param commList the list of comments |
| * @param stName the stereotype name |
| * @return true if remote msg server is necessary, false otherwise |
| */ |
| public Boolean isRemoteMsgServerNecessary (List<Slot> slList, InstanceSpecification procNode, |
| List<InstanceSpecification> connectorInstList, List<Comment> commList, String stName) { |
| |
| List<Slot> boundSlotList = null; |
| |
| for (int i=0; i < slList.size(); i++) { |
| |
| boundSlotList = getBoundRIslotList(slList.get(i), connectorInstList); |
| |
| for (int j=0; j < boundSlotList.size(); j++) { |
| if (! this.getDeploymentProcessingNode(boundSlotList.get(j), commList, stName).equals(procNode)){ |
| return true; |
| } |
| } |
| } |
| |
| return false; |
| } |
| |
| |
| /** |
| * Check whether to use sequence id. |
| * |
| * @param sl the slot |
| * @param connectorInstList the list of connector instances |
| * @param connectorList the list of connectors |
| * @param stName the stereotype name |
| * @return true if sequence id is used, false otherwise |
| */ |
| public Boolean useSequenceID(Slot sl, List<InstanceSpecification> connectorInstList, |
| List<Connector> connectorList, String stName) { |
| |
| // Check that definingFeature and owningInstance of the slot are matching |
| |
| for (int i=0; i<connectorInstList.size(); i++) { |
| List<Slot> slotList = connectorInstList.get(i).getSlots(); |
| |
| // 2 slots are included in the instance of the connector. |
| Slot slot0 = slotList.get(0); |
| Slot slot1 = slotList.get(1); |
| |
| if (slot0.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot0.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| return isTransmissionWithSequenceID(slot0, slot1, connectorList, stName); |
| |
| } |
| } else if (slot1.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot1.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| return isTransmissionWithSequenceID(slot0, slot1, connectorList, stName); |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Checks if the connector has transmission with sequence id. |
| * |
| * @param slot0 the first slot |
| * @param slot1 the second slot |
| * @param connectorList the list of connectors |
| * @param stName the stereotype name |
| * @return true if the connector has transmission with sequence id, false otherwise |
| */ |
| public Boolean isTransmissionWithSequenceID(Slot slot0, Slot slot1, List<Connector> connectorList, String stName) { |
| // assessing whether the connector has a "TransmissionWithProtocol" stereotype on it |
| |
| List<ConnectorEnd> ctEndList = null; |
| |
| for (int i=0; i < connectorList.size(); i++) { |
| ctEndList = connectorList.get(i).getEnds(); |
| ConnectorEnd ce0 = ctEndList.get(0); |
| ConnectorEnd ce1 = ctEndList.get(1); |
| |
| if ((ce0.getRole().equals(slot0.getDefiningFeature()) || ce1.getRole().equals(slot0.getDefiningFeature())) |
| && |
| (ce0.getRole().equals(slot1.getDefiningFeature()) || ce1.getRole().equals(slot1.getDefiningFeature()))) { |
| |
| Stereotype st = connectorList.get(i).getAppliedStereotype(stName); |
| if (st == null) { |
| return false; |
| } else { |
| TransmissionWithProtocol twp = (TransmissionWithProtocol) connectorList.get(i).getStereotypeApplication(st); |
| return twp.isUseSeqID(); |
| } |
| } |
| } |
| return false; |
| } |
| |
| /** |
| * Gets the CRC library. |
| * |
| * @param sl the slot |
| * @param connectorInstList the list of connector instances |
| * @param connectorList the list of connectors |
| * @param stName the stereotype name |
| * @return the CRC library |
| */ |
| public String getCRClib(Slot sl, List<InstanceSpecification> connectorInstList, |
| List<Connector> connectorList, String stName) { |
| |
| // Check that definingFeature and owningInstance of the slot are matching |
| |
| for (int i=0; i<connectorInstList.size(); i++) { |
| List<Slot> slotList = connectorInstList.get(i).getSlots(); |
| |
| // 2 slots are included in the instance of the connector. |
| Slot slot0 = slotList.get(0); |
| Slot slot1 = slotList.get(1); |
| |
| if (slot0.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot0.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| return getTransmissionWithCRC(slot0, slot1, connectorList, stName); |
| |
| } |
| } else if (slot1.getDefiningFeature().equals(sl.getDefiningFeature())) { |
| List<ValueSpecification> vsList = slot1.getValues(); |
| InstanceValue iv = (InstanceValue) vsList.get(0); |
| if (sl.getOwningInstance().equals(iv.getInstance())) { |
| return getTransmissionWithCRC(slot0, slot1, connectorList, stName); |
| } |
| } |
| } |
| return ""; |
| } |
| |
| /** |
| * Gets the transmission with CRC. |
| * |
| * @param slot0 the first slot |
| * @param slot1 the second slot |
| * @param connectorList the list of connectors |
| * @param stName the stereotype name |
| * @return the transmission with CRC |
| */ |
| public String getTransmissionWithCRC(Slot slot0, Slot slot1, List<Connector> connectorList, String stName) { |
| // assessing whether the connector has a "TransmissionWithProtocol" stereotype on it |
| |
| List<ConnectorEnd> ctEndList = null; |
| |
| for (int i=0; i < connectorList.size(); i++) { |
| ctEndList = connectorList.get(i).getEnds(); |
| ConnectorEnd ce0 = ctEndList.get(0); |
| ConnectorEnd ce1 = ctEndList.get(1); |
| |
| if ((ce0.getRole().equals(slot0.getDefiningFeature()) || ce1.getRole().equals(slot0.getDefiningFeature())) |
| && |
| (ce0.getRole().equals(slot1.getDefiningFeature()) || ce1.getRole().equals(slot1.getDefiningFeature()))) { |
| |
| Stereotype st = connectorList.get(i).getAppliedStereotype(stName); |
| if (st == null) { |
| return ""; |
| } else { |
| TransmissionWithProtocol twp = (TransmissionWithProtocol) connectorList.get(i).getStereotypeApplication(st); |
| return twp.getCRC(); |
| } |
| } |
| } |
| return ""; |
| } |
| |
| /** |
| * Gets the Papyrus documentation of an element |
| * |
| * @param elem the Element |
| * @return the documentation as a String |
| */ |
| public String getDocumentation(NamedElement elem){ |
| String docString = ""; |
| EList<Comment> comments = elem.getOwnedComments(); |
| for (Comment comment : comments) { |
| Stereotype documentation = comment.getAppliedStereotype(DOCSTEREO); |
| if(documentation != null){ |
| docString = comment.getBody(); |
| } |
| } |
| String commented = ""; |
| Scanner scanner = new Scanner(docString); |
| while (scanner.hasNextLine()) { |
| String line = scanner.nextLine(); |
| commented += ("-- " + line + System.getProperty("line.separator")); |
| } |
| scanner.close(); |
| return commented; |
| } |
| |
| /** |
| * Gets the tuple attributes of a MARTE's TupleType stereotype. |
| * |
| * @param dt the data type |
| * @param stereo the stereotype (TupleType) |
| * @return the list of proerties that are the tuple attributes |
| */ |
| public List<Property> getTupleAttributes(DataType dt, Stereotype stereo){ |
| TupleType tuple = (TupleType) dt.getStereotypeApplication(stereo); |
| return tuple.getTupleAttrib() ; |
| } |
| |
| /** |
| * checks if the operation generates a function in Ada. |
| * it's a function if there's one and only one parameter with direction "return" |
| * |
| * @param op the operation |
| * @return true if it's a function, false otherwise (it is a procedure) |
| */ |
| public Boolean isFunction(Operation op){ |
| Boolean res = false; |
| int retCount = 0; |
| for (Parameter par : op.getOwnedParameters()) { |
| if(par.getDirection().toString().equals("return")){ |
| retCount++; |
| } |
| } |
| if(retCount == 1){ |
| res = true; |
| } |
| return res; |
| } |
| |
| /** |
| * Gets the return parameter of a given operation. |
| * The given operation must be a function (@see UML2Service.isFunction). |
| * |
| * @param op the given Operation |
| * @return the return parameter of the operation |
| */ |
| public Parameter getReturnParam(Operation op){ |
| Parameter param = null; |
| for (Parameter par : op.getOwnedParameters()) { |
| if(par.getDirection().toString().equals("return")) param = par; |
| } |
| return param; |
| } |
| } |