Google Git
Sign in
eclipse / chess / chess / 44bc673f4e1b5f371f8009ac2777f903cb003583 / . / plugins / org.polarsys.chess.core / src / org / polarsys / chess / core / util / uml / UMLUtils.java
blob: e01f402ae23d7e2fc21a44519bb6054de038429a [file] [log] [blame]
/*
-----------------------------------------------------------------------
-- CHESS core plugin --
-- --
-- Copyright (C) 2011-2012 --
-- University of Padova, ITALY --
-- --
-- Author: Alessandro Zovi azovi@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-v20.html --
-----------------------------------------------------------------------
*/
package org.polarsys.chess.core.util.uml;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import org.eclipse.core.runtime.IAdaptable;
import org.eclipse.emf.common.util.BasicEList;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.Enumerator;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.jface.viewers.IStructuredSelection;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.GQAM.GaLatencyObs;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.GQAM.GaResourcesPlatform;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.GQAM.GaWorkloadEvent;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.SaAnalysisContext;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.SaEndtoEndFlow;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.SaExecHost;
import org.eclipse.papyrus.MARTE.MARTE_AnalysisModel.SAM.SaStep;
import org.eclipse.papyrus.MARTE.MARTE_DesignModel.GCM.ClientServerKind;
import org.eclipse.papyrus.MARTE.MARTE_DesignModel.GCM.ClientServerPort;
import org.eclipse.papyrus.MARTE.MARTE_Foundations.Alloc.Assign;
import org.eclipse.papyrus.infra.emf.utils.BusinessModelResolver;
import org.eclipse.papyrus.infra.emf.utils.EMFHelper;
import org.eclipse.papyrus.uml.tools.model.UmlModel;
import org.eclipse.ui.IWorkbenchWindow;
import org.eclipse.ui.PlatformUI;
import org.eclipse.uml2.uml.Activity;
import org.eclipse.uml2.uml.ActivityNode;
import org.eclipse.uml2.uml.BehavioralFeature;
import org.eclipse.uml2.uml.Class;
import org.eclipse.uml2.uml.Classifier;
import org.eclipse.uml2.uml.Comment;
import org.eclipse.uml2.uml.Component;
import org.eclipse.uml2.uml.Constraint;
import org.eclipse.uml2.uml.Dependency;
import org.eclipse.uml2.uml.Element;
import org.eclipse.uml2.uml.InstanceSpecification;
import org.eclipse.uml2.uml.InstanceValue;
import org.eclipse.uml2.uml.Interface;
import org.eclipse.uml2.uml.InterfaceRealization;
import org.eclipse.uml2.uml.Model;
import org.eclipse.uml2.uml.NamedElement;
import org.eclipse.uml2.uml.Operation;
import org.eclipse.uml2.uml.Package;
import org.eclipse.uml2.uml.Parameter;
import org.eclipse.uml2.uml.Port;
import org.eclipse.uml2.uml.Realization;
import org.eclipse.uml2.uml.Relationship;
import org.eclipse.uml2.uml.Slot;
import org.eclipse.uml2.uml.Stereotype;
import org.eclipse.uml2.uml.ValueSpecification;
import org.eclipse.uml2.uml.VisibilityKind;
import org.eclipse.uml2.uml.internal.impl.DependencyImpl;
import org.polarsys.chess.chessmlprofile.ComponentModel.ComponentImplementation;
import org.polarsys.chess.chessmlprofile.ComponentModel.FunctionalPartition;
import org.polarsys.chess.chessmlprofile.Core.CHGaResourcePlatform;
import org.polarsys.chess.chessmlprofile.Core.PSMPackage;
import org.polarsys.chess.chessmlprofile.Predictability.ARINCComponentModel.ARINCFunction;
import org.polarsys.chess.chessmlprofile.Predictability.ARINCComponentModel.ARINCProcess;
import org.polarsys.chess.chessmlprofile.Predictability.DeploymentConfiguration.HardwareBaseline.CH_HwProcessor;
import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtPortSlot;
import org.polarsys.chess.chessmlprofile.Predictability.RTComponentModel.CHRtSpecification;
import org.polarsys.chess.chessmlprofile.Safety.CriticalityLevel;
import org.polarsys.chess.chessmlprofile.util.Constants;
import org.polarsys.chess.core.notifications.ResourceNotification;
import org.polarsys.chess.core.profiles.CHESSProfileManager;
import org.polarsys.chess.core.util.AnalysisResultData;
import org.polarsys.chess.core.util.CHESSProjectSupport;
import org.polarsys.chess.core.util.EndToEndResultData;
import org.polarsys.chess.core.util.HWAnalysisResultData;
import org.polarsys.chess.core.views.ViewUtils;
/**
* This class contains a list of utility methods to deal with UML models.
*
*/
public class UMLUtils {
/**
* Returns the XML ID (UUID) of a model element.
* It may be useful for external tools to precisely refer to a model element.
*
* @param el the model element
* @return the UUID
*/
public static String getElementID(Element el){
Resource resource = el.eResource();
if(resource != null)
return resource.getURIFragment(el);
return null;
}
/**
* Checks if the given operation is public.
*
* @param operation the operation
* @return true if it is public
*/
public static boolean hasPublicVisibility(Operation operation) {
if (operation.getVisibility().getValue() == VisibilityKind.PUBLIC)
return true;
return false;
}
/**
* Checks if two parameters are the same.
*
* @param param the source parameter
* @param aux the target paramater
* @return true if they are the same
*/
public static boolean areParametersEqual(Parameter param, Parameter aux) {
// parameter's name
if (!param.getName().equals(aux.getName()))
return false;
// parameter's direction
if (param.getDirection().getValue() != aux.getDirection().getValue())
return false;
// parameter's visibility
if (param.getVisibility().getValue() != aux.getVisibility().getValue())
return false;
if (param.isException() != aux.isException())
return false;
if (param.isMultivalued() != aux.isMultivalued())
return false;
if (param.isOrdered() != aux.isOrdered())
return false;
if (param.isSetDefault() != aux.isSetDefault())
return false;
if (param.isUnique() != aux.isUnique())
return false;
if (param.isStream() != aux.isStream())
return false;
if (param.getEffect().getValue() != aux.getEffect().getValue())
return false;
if (param.lowerBound() != aux.lowerBound())
return false;
if (param.upperBound() != aux.upperBound())
return false;
return true;
}
/**
* Copy the source operation data to the target operation.
*
* @param source the source operation
* @param target the target operation
*/
public static void copyOperation(Operation source, Operation target)
{
for (Parameter param : source.getOwnedParameters()) {
Parameter p = target.createOwnedParameter(param.getName(), param.getType());
p.setDirection(param.getDirection());
p.setEffect(param.getEffect());
p.setDefaultValue(param.getDefaultValue());
p.setDefault(param.getDefault());
p.setIsException(param.isException());
p.setIsOrdered(param.isOrdered());
p.setIsStream(param.isStream());
p.setIsUnique(param.isUnique());
p.setLower(param.getLower());
p.setLowerValue(param.getLowerValue());
p.setTemplateParameter(param.getTemplateParameter());
p.setUpper(param.getUpper());
p.setUpperValue(param.getUpperValue());
p.setVisibility(param.getVisibility());
}
target.setVisibility(source.getVisibility());
target.setConcurrency(source.getConcurrency());
target.setIsQuery(source.isQuery());
target.setIsLeaf(source.isLeaf());
target.setIsStatic(source.isStatic());
//target.getRedefinedOperations().add(source);
}
/* public static boolean isOperationEquals(Operation source, Operation target) {
// check the parameters
Parameter param, aux;
EList<Parameter> targetList = target.getOwnedParameters();
// check their order
if (targetList.size() != source.getOwnedParameters().size())
return false;
if (source.getVisibility().getValue() != target.getVisibility()
.getValue())
return false;
if (source.isQuery() != target.isQuery())
return false;
if (source.isLeaf() != target.isLeaf())
return false;
if (source.isStatic() != target.isStatic())
return false;
if (source.getConcurrency().getValue() != target.getConcurrency()
.getValue())
return false;
for (int i = 0; i < targetList.size(); i++) {
param = targetList.get(i);
aux = source.getOwnedParameter(param.getName(), param.getType());
if (aux == null)
return false;
// aux = targetList.get(i);
if (param != null && aux != null) {
if (!isParameterEquals(param, aux))
return false;
}
}
return true;
}*/
/**
* If parameter 'p' is null checks if the operations are the same, that is if they have the same signature.
* If parameter 'p' is not null returns true only if the target operation plus 'p' has the same signature of the source operation.
*
*
* @param source the source operation
* @param target the target operation
* @param p the parameter
* @return true if the operations are equal
*/
public static boolean areOperationsEqual(Operation source, Operation target, Parameter p)
{
if ( !source.getName().equalsIgnoreCase(target.getName()))
return false;
// check the parameters
Parameter param, aux;
EList<Parameter> targetList = target.getOwnedParameters();
EList<Parameter> sourceList = source.getOwnedParameters();
// check their order
if ( p == null )
{
if (targetList.size() != sourceList.size())
return false;
}
else
if (targetList.size() + 1 != sourceList.size())
return false;
if (source.getVisibility().getValue() != target.getVisibility()
.getValue())
return false;
if (source.isQuery() != target.isQuery())
return false;
if (source.isLeaf() != target.isLeaf())
return false;
if (source.isStatic() != target.isStatic())
return false;
if (source.getConcurrency().getValue() != target.getConcurrency()
.getValue())
return false;
for (int i = 0; i < targetList.size(); i++) {
param = targetList.get(i);
aux = source.getOwnedParameter(param.getName(), param.getType());
if (aux == null)
return false;
// aux = targetList.get(i);
if (param != null && aux != null) {
if (!areParametersEqual(param, aux))
return false;
}
}
return true;
}
/**
* Checks if the list of parameters of two operations are equal.
* If 'p' is not null returns true only if source operation deprived of 'p' has the same list of parameters
* of the target operation.
*
* @param source the source operation
* @param target the target operation
* @param p the parameter
* @return true if the operation parameters are equal
*/
public static boolean areParametersEquals(Operation source, Operation target, Parameter p) {
EList<Parameter> targetList = target.getOwnedParameters();
if (targetList.size() != source.getOwnedParameters().size())
return false;
for (Parameter param : targetList) {
if (p != null && p.getName().equalsIgnoreCase(param.getName()))
continue;
Parameter aux = source.getOwnedParameter(param.getName(),
param.getType());
if (aux == null)
return false;
if (!areParametersEqual(param, aux))
return false;
}
return true;
}
/**
* Checks if the parameters of two operations are the same.
*
* @param source the source
* @param target the target
* @return true, if successful
*/
public static boolean areParametersEquals(Operation source, Operation target)
{
return areParametersEquals(source,target,null);
}
/**
* Checks if two operations are equal.
*
* @param source one operation
* @param target the other
* @return true if they are equal
*/
public static boolean isOperationEquals(Operation source, Operation target) {
return UMLUtils.areOperationsEqual(source, target, null);
}
/**
* Checks if there given Component offers an operation that is equal
* of the operation given.
*
* @param component the component
* @param operation the operation
* @return true if there is an operation that equals the given one
*/
public static boolean isOperationContained(Classifier component,
Operation operation) {
for (Operation op : component.getOperations()) {
// check the name
if (op.getName().equals(operation.getName())) {
if (isOperationEquals(op, operation))
return true;
}
}
return false;
}
/**
* Retrieves all the clients of a given {@link Interface}.
*
* @param interfce the interface
* @return the list of clients
*/
public static EList<NamedElement> getInterfaceClients(Interface interfce){
EList<NamedElement> relationships = new BasicEList<NamedElement>();
for (Relationship rel : interfce.getRelationships()) {
if (rel instanceof InterfaceRealization) {
InterfaceRealization intRel = (InterfaceRealization) rel;
relationships.addAll(intRel.getClients());
}
}
return relationships;
}
/**
* Retrieves all the {@link ComponentImplementation} of a given Component.
*
* @param comp the component
* @return the list of {@link ComponentImplementation}
*/
public static EList<Component> getComponentImplementations(Component comp){
EList<Component> list = new BasicEList<Component>();
//DONE using comp.getNearestPackage() is NOT SAFE, use a recursive search on the ViewUtils.getView(comp)
EList<Component> compImpls = retrieveComponentImplementations(ViewUtils.getView(comp));
for (Component el : compImpls) {
for (Dependency dep : el.getClientDependencies()) {
if (dep instanceof Realization) {
if (dep.getSupplier(comp.getName()) != null)
list.add(el);
}
}
}
return list;
}
/**
* Retrieves all the {@link ComponentImplementation} of a given Package.
*
* @param pkg the package
* @return all the {@link ComponentImplementation}
*/
private static EList<Component> retrieveComponentImplementations(Package pkg) {
EList<Component> comps = new BasicEList<Component>();
for (Element el : pkg.getOwnedElements()) {
if (el instanceof Component && isComponentImplementation(el)){
comps.add((Component) el);
}
if (el instanceof Package){
EList<Component> list = retrieveComponentImplementations((Package) el);
if (!list.isEmpty())
comps.addAll(list);
}
}
return comps;
}
/**
* Checks if the given object is a {@link ComponentType}.
*
* @param el the element
* @return true if it is a {@link ComponentType}
*/
public static boolean isComponentType(Object el) {
if (el instanceof Component && ((Element) el).getAppliedStereotype(Constants.COMPONENT_TYPE) != null)
return true;
return false;
}
/**
* Checks if the given object is a {@link ComponentImplementation}.
*
* @param el the element
* @return true if it is a {@link ComponentImplementation}
*/
public static boolean isComponentImplementation(Object el) {
if (el instanceof Component && ((Element) el).getAppliedStereotype(Constants.COMPONENT_IMPLEMENTATION) != null)
return true;
return false;
}
/**
* Retrieves the list of {@link ClientServerPort} of a given Component.
*
* @param component the component
* @return the list of {@link ClientServerPort}
*/
public static EList<ClientServerPort> getComponentClientServerPorts(final Component component) {
EList<ClientServerPort> ports = new BasicEList<ClientServerPort>();
for (Element e : component.getOwnedElements()) {
if (e instanceof Port) {
Port p = (Port) e;
for (EObject st : p.getStereotypeApplications()) {
if (st instanceof ClientServerPort){
ClientServerPort csp = (ClientServerPort) st;
ports.add(csp);
}
}
}
}
return ports;
}
/**
* Retrieves all the {@link Dependency} of a given Component.
*
* @param comp the component
* @return the list of {@link Dependency}
*/
public static EList<Dependency> computeDependenciesToRemove(Component comp) {
EList<Dependency> cDependencies = comp.getClientDependencies();
EList<Interface> cDependentInterfaces = new BasicEList<Interface>();
Map<Interface, Dependency> cDependenciesToRemoveMap = new HashMap<Interface, Dependency>();
for (Dependency dependency : cDependencies) {
//it MUST BE exactly a Dependency since a InterfaceRealization is a subtype of Dependency :(
if (dependency.getClass().equals(DependencyImpl.class)){
for (NamedElement el : dependency.getSuppliers()) {
//There's MUST be one and only interface per dependency relationship
if (el instanceof Interface){
cDependentInterfaces.add((Interface)el);
cDependenciesToRemoveMap.put((Interface)el, dependency);
}
}
}
}
EList<ClientServerPort> ports = UMLUtils.getComponentClientServerPorts(comp);
EList<Interface> portInts = new BasicEList<Interface>();
for (ClientServerPort csp : ports) {
if (csp.getKind() == ClientServerKind.REQUIRED || csp.getKind() == ClientServerKind.PROREQ) {
portInts.addAll(csp.getReqInterface());
}
}
if (portInts != null)
cDependentInterfaces.removeAll(portInts);
EList<Dependency> cDependenciesToRemove = new BasicEList<Dependency>();
for (Interface el : cDependentInterfaces) {
Dependency dep = cDependenciesToRemoveMap.get(el);
if (dep != null){
cDependenciesToRemove.add(dep);
}
}
return cDependenciesToRemove;
}
/**
* Retrieves all the {@link InterfaceRealization} of a given Component.
*
* @param comp the component
* @return the list of {@link InterfaceRealization}
*/
public static EList<InterfaceRealization> computeRealizationsToRemove(
Component comp) {
EList<InterfaceRealization> cRealizations = comp.getInterfaceRealizations();
EList<Interface> cRealizedInterfaces = new BasicEList<Interface>();
Map<Interface, InterfaceRealization> cRealizationsToRemoveMap = new HashMap<Interface, InterfaceRealization>();
for (InterfaceRealization ir : cRealizations) {
//it MUST BE exactly a Dependency since a InterfaceRealization is a subtype of Dependency :(
cRealizedInterfaces.add(ir.getContract());
cRealizationsToRemoveMap.put(ir.getContract(), ir);
}
EList<ClientServerPort> ports = UMLUtils.getComponentClientServerPorts(comp);
EList<Interface> portInts = new BasicEList<Interface>();
for (ClientServerPort csp : ports) {
if (csp.getKind() == ClientServerKind.PROVIDED || csp.getKind() == ClientServerKind.PROREQ) {
portInts.addAll(csp.getProvInterface());
}
}
if (portInts != null)
cRealizedInterfaces.removeAll(portInts);
EList<InterfaceRealization> cRealizationsToRemove = new BasicEList<InterfaceRealization>();
for (Interface el : cRealizedInterfaces) {
InterfaceRealization dep = cRealizationsToRemoveMap.get(el);
if (dep != null){
cRealizationsToRemove.add(dep);
}
}
return cRealizationsToRemove;
}
/**
* Checks if the given object represents a Client/Server port.
*
* @param el the element
* @return true if the object is a Client/Server port
*/
public static boolean isClientServerPort(final Object el) {
if(el instanceof Port && ((Element) el).getAppliedStereotype(Constants.CLIENTSERVER_PORT) != null)
return true;
return false;
}
/**
* Returns the CHRtSpecification of the given element.
* Returns null if the element is not a the comment
*
* @param el the element
* @return the CHRtSpecification application
*/
public static Stereotype getCHRtSpecification(final Object el) {
if(el instanceof Comment)
return ((Element) el).getAppliedStereotype(Constants.CHRT_SPECIFICATION);
return null;
}
/**
* Retrieves all the CHRTSpecification {@link Comment}s given a Package and a Port.
* If the Port is not given it retrieves all the comments.
*
* @param pkg the package
* @param portFilter the port, can be null
* @return the list of comments
*/
public static EList<Comment> getCHRtSpecificationComments(Package pkg, Port portFilter) {
EList<Comment> chrtspecs = new BasicEList<Comment>();
for (Element el : pkg.getOwnedElements()) {
if (!(el instanceof Component)) continue;
for (Comment comm : el.getOwnedComments()) {
Stereotype chrtspecification;
if ((chrtspecification = getCHRtSpecification(comm)) != null) {
if (portFilter!=null){
if (comm.getValue(chrtspecification, Constants.CHRTSPEC_PARTWITHPORT) != null
&& comm.getValue(chrtspecification, Constants.CHRTSPEC_PARTWITHPORT).equals(portFilter)) {
chrtspecs.add(comm);
}
} else {
chrtspecs.add(comm);
}
}
}
}
return chrtspecs;
}
/**
* Returns the stereotype object given the stereotype class and the model element.
*
*
* @param <T> the generic type
* @param element the element
* @param stereotypeClass the stereotype class
* @return the stereotype object
*/
@SuppressWarnings("unchecked")
public static <T extends EObject> T getStereotypeApplication(
final Element element, final java.lang.Class<T> stereotypeClass) {
for (EObject stereoApplication : element.getStereotypeApplications()) {
if (stereotypeClass.isInstance(stereoApplication)) {
return (T) stereoApplication;
}
}
return null;
}
/**
* Retrieves all the {@link Component} implementing the given interface.
*
* @param interfce the {@link Interface}
* @return the list of Components or an empty list
*/
public static EList<Component> getAllInterfaceComponents(final Interface interfce) {
EList<Component> list = new BasicEList<Component>();
for (NamedElement el : getInterfaceClients(interfce)) {
if (el instanceof Component && isComponentType(el)) {
list.add((Component) el);
EList<Component> compList = getComponentImplementations((Component) el);
if (!compList.isEmpty())
list.addAll(compList);
}
};
return list;
}
/**
* Returns the {@link Stereotype} of a given element based on the qualified name, or null.
*
* @param element the element
* @param qualifiedName the qualified name
* @return the stereotype or null
*/
public static Stereotype getStereotype(final Element element,
final String qualifiedName) {
Stereotype str = element.getApplicableStereotype(qualifiedName);
return str;
}
/**
* Applies the {@link Stereotype} to a given element based on the qualified name.
* It returns the applied stereotype or null.
*
* @param element the element
* @param qualifiedName the qualified name
* @return the stereotype applied or null
*/
public static Stereotype applyStereotype(final Element element,
final String qualifiedName) {
Stereotype str = getStereotype(
element,
qualifiedName);
if (str != null)
element.applyStereotype(str);
return str;
}
/**
* Returns the list of assignments found in viewName where
* the source anything and the target is a Processor Instance.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the all 2 core assignments
* @throws ModelError the model error
*/
public static EList<Assign> getAll2CoreAssignments(Model umlModel,
String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
// get them all
assignments.add(a);
}
}
return assignments;
}
/**
* Returns the list of assignments found in viewName where
* the source is a Component Instance and the target is a Processor Instance.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the component 2 core assignments
* @throws ModelError the model error
*/
public static EList<Assign> getComponent2CoreAssignments(Model umlModel,
String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
Element assignmentTarget = a.getTo().get(0);
// SOURCE must be a Component
// TARGET must be a Processor
if (elementIsProcessorInstance(assignmentTarget)) {
if(elementIsComponentInstance(assignmentSource)) {
InstanceSpecification componentInst = (InstanceSpecification) assignmentSource;
if (isComponentInstance(componentInst)) {
assignments.add(a);
}
}
}
}
catch (Exception e) {
continue;
}
}
}
return assignments;
}
/**
* Returns the list of assignments found in viewName where
* the source is a Partition Instance and the target is a Processor Instance.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the all partition assignments
* @throws ModelError the model error
*/
public static EList<Assign> getAllPartitionAssignments(Model umlModel,
String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
Element assignmentTarget = a.getTo().get(0);
// SOURCE must be a Partition
// TARGET must be a Processor
if (elementIsPartitionInstance(assignmentSource) &&
elementIsProcessorInstance(assignmentTarget)) {
assignments.add(a);
}
// SOURCE must be a Component
// TARGET must be a Partition
if (elementIsPartitionInstance(assignmentTarget)) {
if(elementIsComponentInstance(assignmentSource)) {
InstanceSpecification componentInst = (InstanceSpecification) assignmentSource;
if (isComponentInstance(componentInst)) {
assignments.add(a);
}
}
}
}
catch (Exception e) {
continue;
}
}
}
return assignments;
}
/**
* Returns all the assignments that have the input functional partition
* either in the To field (Component to Partition Assignment), or
* in the From field (Partition to ProcessorAssignment).
*
* @param umlModel the uml model
* @param functPart the funct part
* @return the partition assignments
* @throws ModelError the model error
*/
public static EList<Assign> getPartitionAssignments(Model umlModel, FunctionalPartition functPart)
throws ModelError {
// We look for the Assignments from Partition to Core in the Deployment View
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
Constants.DEPLOYMENT_VIEW_NAME);
EList<Element> allDeplViewElems = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : allDeplViewElems) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
Element assignmentTarget = a.getTo().get(0);
// SOURCE must be a Partition
// TARGET must be a Processor
if (elementIsPartitionInstance(assignmentSource)) {
if(elementIsProcessorInstance(assignmentTarget)) {
// Check if the involved partition is functPart
InstanceSpecification instSpecSource = (InstanceSpecification)assignmentSource;
if (instSpecSource.getClassifiers().get(0).equals(functPart.getBase_Component())) {
assignments.add(a);
}
}
}
}
catch (Exception e) {
continue;
}
}
}
// We look for the Assignments from Component to Partition in the Component View
parent = CHESSProfileManager.getViewByStereotype(umlModel,
Constants.COMPONENT_VIEW_NAME);
EList<Element> allCompViewElems = parent.allOwnedElements();
for (Element element : allCompViewElems) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
Element assignmentTarget = a.getTo().get(0);
// SOURCE must be a Component
// TARGET must be a Partition
if (elementIsPartitionInstance(assignmentTarget)) {
if(elementIsComponentInstance(assignmentSource)) {
InstanceSpecification instSpecSource = (InstanceSpecification) assignmentSource;
if (isComponentInstance(instSpecSource)) {
InstanceSpecification instSpecTarget = (InstanceSpecification)assignmentTarget;
// its type should be the same as the input functional Partition
if (instSpecTarget.getClassifiers().get(0).equals(functPart.getBase_Component())) {
assignments.add(a);
}
}
}
}
}
catch (Exception e) {
continue;
}
}
}
return assignments;
}
/**
* Returns the list of assignments found in viewName where
* the source is a Partition Instance and the target is a Processor Instance.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the partition 2 core assignments
* @throws ModelError the model error
*/
public static EList<Assign> getPartition2CoreAssignments(Model umlModel,
String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
Element assignmentTarget = a.getTo().get(0);
// SOURCE must be a Partition
// TARGET must be a Processor
if (elementIsPartitionInstance(assignmentSource) &&
elementIsProcessorInstance(assignmentTarget)) {
assignments.add(a);
}
}
catch (Exception e) {
continue;
}
}
}
return assignments;
}
/**
* Returns the list of assignments found in viewName where
* the source is a Slot Instance and the target is a Processor Instance.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the task 2 core assignments
* @throws ModelError the model error
*/
public static EList<Assign> getTask2CoreAssignments(Model umlModel,
String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
Element assignmentTarget = a.getTo().get(0);
// SOURCE must be a Task
// TARGET must be a Processor
if (elementIsSlotInstance(assignmentSource) &&
elementIsProcessorInstance(assignmentTarget)) {
assignments.add(a);
}
}
catch (Exception e) {
continue;
}
}
}
return assignments;
}
/**
* Returns the list of assignments found in viewName where
* the source is a Component Instance .
*
* @param umlModel the uml model
* @param viewName the view name
* @return the component assignments
* @throws ModelError the model error
*/
public static EList<Assign> getComponentAssignments(Model umlModel, String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
// SOURCE must be a Component
// TARGET can be anything
if(elementIsComponentInstance(assignmentSource)) {
InstanceSpecification componentInst = (InstanceSpecification) assignmentSource;
if (isComponentInstance(componentInst)) {
assignments.add(a);
}
}
}
catch (Exception e) {
continue;
}
}
}
return assignments;
}
/**
* Gets the resource platform component.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the resource platform component
* @throws ModelError the model error
*/
public static Component getResourcePlatformComponent(Model umlModel, String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
if(parent == null)
throw new ModelError(viewName+" not found.");
/* breath-first search */
final LinkedList<Element> breadthFirstList = new LinkedList<Element>();
breadthFirstList.addAll(parent.getOwnedElements());
while (!breadthFirstList.isEmpty()) {
final Element t = breadthFirstList.poll();
if (t instanceof Component) {
Component candidate = (Component) t;
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(
candidate, CHGaResourcePlatform.class);
if (a != null)
return candidate;
}
for (final Element e : t.getOwnedElements()) {
breadthFirstList.addLast(e);
}
}
throw new ModelError("CHGaResourcePlatform not found in "+viewName+" view.");
}
/**
* Looks inside the input package pack, and returns a Component stereotyped as CHGaResourcePlatform .
*
* @param umlModel the uml model
* @param pack the pack
* @return the resource platform component in package
* @throws ModelError the model error
*/
public static Component getResourcePlatformComponentInPackage(Model umlModel,
Package pack) throws ModelError {
/* breath-first search */
final LinkedList<Element> breadthFirstList = new LinkedList<Element>();
breadthFirstList.addAll(pack.getOwnedElements());
while (!breadthFirstList.isEmpty()) {
final Element t = breadthFirstList.poll();
if (t instanceof Component) {
Component candidate = (Component) t;
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(
candidate, CHGaResourcePlatform.class);
if (a != null)
return candidate;
}
for (final Element e : t.getOwnedElements()) {
breadthFirstList.addLast(e);
}
}
throw new ModelError("CHGaResourcePlatform not found in "+pack.getName()+" package.");
}
/**
* Returns TRUE if the element is a processor instance, FALSE otherwise.
*
* @param element the element
* @return true, if successful
*/
public static boolean elementIsProcessorInstance(Element element) {
if (!(element instanceof InstanceSpecification)) {
return false;
}
InstanceSpecification is = (InstanceSpecification) element;
if (is.getQualifiedName() != null
&& isProcessorInstance(is)) {
return true;
}
return false;
}
/**
* Returns TRUE if the instanceSpecification is a processor instance, FALSE otherwise.
*
* @param e the e
* @return true, if is processor instance
*/
public static boolean isProcessorInstance(InstanceSpecification e) {
for (Classifier c : e.getClassifiers()) {
if (UMLUtils.getStereotypeApplication(c, CH_HwProcessor.class) != null)
return true;
}
return false;
}
/**
* Returns TRUE if the element is a component instance, false otherwise.
*
* @param element the element
* @return true, if successful
*/
public static boolean elementIsComponentInstance(Element element) {
if (!(element instanceof InstanceSpecification)) {
return false;
}
InstanceSpecification is = (InstanceSpecification) element;
if (is.getQualifiedName() != null
&& isComponentInstance(is)) {
return true;
}
return false;
}
/**
* Returns TRUE if the InstanceSpecification is a component instance, false otherwise.
*
* @param e the e
* @return true, if is component instance
*/
public static boolean isComponentInstance(InstanceSpecification e) {
for (Classifier c : e.getClassifiers()) {
if (UMLUtils.getStereotypeApplication(c,
ComponentImplementation.class) != null)
return true;
}
return false;
}
/**
* Returns the number of CPUs to which the InstanceSpecification is assigned .
*
* @param i the instance specification
* @param theDeploymentElem the deployment for which the count is performed
* @param assignments the assignments
* @return the number of CPUs to which the InstanceSpecification is assigned for the given deployment
*/
public static int isAssigned2HowManyProcessingUnits(InstanceSpecification i,
Element theDeploymentElem, EList<Assign> assignments) {
int count = 0;
for (Assign theAssignment : assignments) {
if (theAssignment != null) {
try {
Element toElem = theAssignment.getTo().get(0);
if (theAssignment.getFrom().contains((Object)i) &&
elementIsProcessorInstance(theAssignment.getTo().get(0))) {
Element chgaResPlat = toElem.getOwner();
if (theDeploymentElem.equals(chgaResPlat)) {
count++;
}
}
}
catch (Exception e) {
continue;
}
}
}
return count;
}
/**
* Returns the number of CPUs or FunctionalPartitions to which the InstanceSpecification is assigned .
*
* @param i the instance specification
* @param theDeploymentElem the deployment for which the count is performed
* @param assignments the assignments
* @return the number of CPUs or FunctionalPartitions to which the InstanceSpecification is assigned for the given deployment
*/
public static int isAssigned2HowManyProcessingUnitsOrPartitions(InstanceSpecification i,
Element theDeploymentElem, EList<Assign> assignments) {
int count = 0;
for (Assign theAssignment : assignments) {
if (theAssignment != null) {
try {
Element toElem = theAssignment.getTo().get(0);
if (theAssignment.getFrom().contains((Object)i) &&
(elementIsProcessorInstance(toElem) ||
elementIsPartitionInstance(toElem))) {
Element chgaResPlat = toElem.getOwner();
if(chgaResPlat.equals(theDeploymentElem)) {
count++;
}
}
}
catch (Exception e) {
continue;
}
}
}
return count;
}
/**
* Returns the number of FunctionalPartitions to which the InstanceSpecification is assigned .
*
* @param i the i
* @param assignments the assignments
* @return the int
*/
public static int isAssigned2HowManyPartitions(InstanceSpecification i, EList<Assign> assignments) {
int count = 0;
for (Assign theAssignment : assignments) {
if (theAssignment != null) {
try {
Element toElem = theAssignment.getTo().get(0);
if (theAssignment.getFrom().contains((Object)i) &&
(elementIsProcessorInstance(toElem) ||
elementIsPartitionInstance(toElem))) {
count++;
}
}
catch (Exception e) {
continue;
}
}
}
return count;
}
/**
* Returns the list of all partition instances in the model.
*
* @param umlModel the uml model
* @return the all partition instances
* @throws ModelError the model error
*/
public static EList<InstanceSpecification> getAllPartitionInstances(
Model umlModel) throws ModelError {
Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel,
CHESSProfileManager.COMPONENT_VIEW);
if(cmpv==null)
throw new ModelError("Component view not found.");
cmpv = getResourcePlatformPackage(cmpv);
if(cmpv==null)
throw new ModelError("CHGaResourcePlatform not found in Component View.");
EList<Element> all = cmpv.allOwnedElements();
EList<InstanceSpecification> partitions = new BasicEList<InstanceSpecification>();
for (Element element : all) {
if (!(element instanceof InstanceSpecification)) continue;
InstanceSpecification is = (InstanceSpecification) element;
if (!(is.getQualifiedName() != null
&& isPartitionInstance(is))) continue;
partitions.add(is);
}
if(partitions.size()==0)
throw new ModelError("Partition Instances not found.");
return partitions;
}
/**
* Gets the resource platform package.
*
* @param cmpv the cmpv
* @return the resource platform package
*/
public static Package getResourcePlatformPackage(Package cmpv) {
/* breath-first search */
final LinkedList<Package> breadthFirstList = new LinkedList<Package>();
breadthFirstList.addFirst(cmpv);
while (!breadthFirstList.isEmpty()) {
final Package candidate = breadthFirstList.poll();
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(
candidate, CHGaResourcePlatform.class);
if (a != null)
return candidate;
for (final Package p : candidate.getNestedPackages()) {
breadthFirstList.addLast(p);
}
}
return null;
}
/**
* Gets the all resource platform package.
*
* @param cmpv the cmpv
* @return the all resource platform package
*/
public static EList<Package> getAllResourcePlatformPackage(Package cmpv) {
/* breath-first search */
EList<Package> result = new BasicEList<Package>();
final LinkedList<Package> breadthFirstList = new LinkedList<Package>();
breadthFirstList.addFirst(cmpv);
while (!breadthFirstList.isEmpty()) {
final Package candidate = breadthFirstList.poll();
CHGaResourcePlatform a = UMLUtils.getStereotypeApplication(
candidate, CHGaResourcePlatform.class);
if (a != null) {
result.add(candidate);
//return candidate;
}
for (final Package p : candidate.getNestedPackages()) {
breadthFirstList.addLast(p);
}
}
//return null;
return result;
}
/**
* Returns TRUE if the instance specification is a partition instance.
*
* @param e the e
* @return true, if is partition instance
*/
public static boolean isPartitionInstance(InstanceSpecification e) {
for (Classifier c : e.getClassifiers()) {
if (UMLUtils.getStereotypeApplication(c, FunctionalPartition.class) != null)
return true;
}
return false;
}
/**
* Element is partition instance.
*
* @param element the element
* @return true if the element is a partition instance, false otherwise
*/
public static boolean elementIsPartitionInstance(Element element) {
if (!(element instanceof InstanceSpecification)) {
return false;
}
InstanceSpecification is = (InstanceSpecification) element;
if (is.getQualifiedName() != null
&& isPartitionInstance(is)) {
return true;
}
return false;
}
/**
* Check if this Partition is assigned to a CPU .
*
* @param i the i
* @param assignments the assignments
* @return true, if is assigned 2 core
*/
public static boolean isAssigned2Core(InstanceSpecification i,
EList<Assign> assignments) {
for (Assign theAssignment : assignments) {
if (theAssignment != null) {
try {
if (theAssignment.getFrom().contains((Object)i) &&
elementIsProcessorInstance(theAssignment.getTo().get(0))) {
return true;
}
}
catch (Exception e) {
continue;
}
}
}
return false;
}
/**
* Check if this Partition has at least a component assigned to it.
*
* @param i the i
* @param assignments the assignments
* @return true, if successful
*/
public static boolean hasComponentAssigned(InstanceSpecification i,
EList<Assign> assignments) {
for (Assign theAssignment : assignments) {
if (theAssignment != null) {
try {
if (theAssignment.getTo().contains((Object)i) &&
elementIsPartitionInstance(theAssignment.getTo().get(0))) {
return true;
}
}
catch (Exception e) {
continue;
}
}
}
return false;
}
/**
* Returns the list of assignments found in viewName .
*
* @param umlModel the uml model
* @param viewName the view name
* @return the assignments
* @throws ModelError the model error
*/
public static EList<Assign> getAssignments(Model umlModel, String viewName) throws ModelError {
// LB 20150928 look in all the package (some models may not have the CHGAResourcePlatform component)
//Component rpc = getResourcePlatformComponent(umlModel, viewName);
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
assignments.add(a);
}
}
return assignments;
}
/**
* Element is slot instance.
*
* @param element the element
* @return true, if successful
*/
public static boolean elementIsSlotInstance(Element element) {
return element instanceof Slot;
}
/**
* Verifies if element is a CHRtPortSlot Slot.
*
* @param elem the elem
* @return true, if successful
*/
public static boolean elementIsCHRtPortSlot(Element elem) {
if (!elementIsSlotInstance(elem)) {
return false;
}
if(elem.getAppliedStereotype(Constants.CH_CHRtPortSlot) != null) {
return true;
}
return false;
}
/**
* Returns the list of all Component Instances found in the Component View if onlyTerminal is FALSE,
* Returns the list of all terminal Component Instances found in the Component View if onlyTerminal is TRUE.
*
* @param umlModel the uml model
* @param onlyTerminal the only terminal
* @return the all component instances
* @throws ModelError the model error
*/
public static EList<InstanceSpecification> getAllComponentInstances(
Model umlModel, boolean onlyTerminal) throws ModelError {
Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel,
CHESSProfileManager.COMPONENT_VIEW);
if(cmpv==null)
throw new ModelError("Component view not found.");
cmpv = UMLUtils.getResourcePlatformPackage(cmpv);
if(cmpv==null)
throw new ModelError("CHGaResourcePlatform not found in Component View.");
EList<Element> all = cmpv.allOwnedElements();
EList<InstanceSpecification> components = new BasicEList<InstanceSpecification>();
for (Element element : all) {
if (!(element instanceof InstanceSpecification)) continue;
InstanceSpecification is = (InstanceSpecification) element;
if (!(is.getQualifiedName() != null
&& UMLUtils.isComponentInstance(is))) continue;
if (onlyTerminal) {
// 20160601 Only consider leaf elements
if (!UMLUtils.isLeafComponentInstance(is)) {
continue;
}
}
components.add(is);
}
if(components.size()==0)
throw new ModelError("Component Instances not found.");
return components;
}
/**
* Checks if is leaf component instance.
*
* @param instSpec the inst spec
* @return true if the Instance Specification does not contain any ComponentImplementations (i.e. it is a leaf)
* false otherwise
*/
public static boolean isLeafComponentInstance(InstanceSpecification instSpec) {
if (instSpec.getOwnedElements().size() > 0) {
//System.out.println("Looking at instSpec="+instSpec.getName());
EList<Element> theOwnedElems = instSpec.getOwnedElements();
for (Element theOwnedElem : theOwnedElems) {
if (theOwnedElem instanceof Slot) {
Slot theSlot = (Slot)theOwnedElem;
EList<ValueSpecification> valSpecs = theSlot.getValues();
for (ValueSpecification valSpec: valSpecs) {
if (valSpec instanceof InstanceValue){
InstanceSpecification theInstance = ((InstanceValue) valSpec).getInstance();
for (Classifier instClassifier : theInstance.getClassifiers()) {
if (instClassifier instanceof Component) {
Component instComp = (Component) instClassifier;
// Is the component a ComponentImplementation?
Stereotype compImplStereo = instComp.getAppliedStereotype(Constants.COMPONENT_IMPLEMENTATION);
if (compImplStereo != null) {
// This is not a leaf component, as it is parent of some ComponentImplementation
return false;
}
}
}
}
}
}
}
}
return true;
}
/**
* Looks for all the Component to Functional Partition Assignments in the specified View.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the component 2 partition assignments
* @throws ModelError the model error
*/
public static EList<Assign> getComponent2PartitionAssignments(Model umlModel,
String viewName) throws ModelError {
// LB 20150708 we now look for assignments in the CHGA resource platform component
//Package cmpv = CHESSProfileManager.getViewByStereotype(umlModel, viewName);
//cmpv = QueryUtils.getResourcePlatformPackage(cmpv);
//Component rpc = QueryUtils.getResourcePlatformComponent(umlModel, viewName);
// LB 20150928 look in all the package (some models may not have the CHGAResourcePlatform component)
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<Assign> assignments = new BasicEList<Assign>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.ASSIGN)!=null)) {
stereo = element.getAppliedStereotype(Constants.ASSIGN);
EObject eobj = element.getStereotypeApplication(stereo);
Assign a = (Assign)eobj;
try {
Element assignmentSource = a.getFrom().get(0);
Element assignmentTarget = a.getTo().get(0);
// SOURCE must be a Component
// TARGET must be a Partition
if (elementIsPartitionInstance(assignmentTarget)) {
if(elementIsComponentInstance(assignmentSource)) {
InstanceSpecification componentInst = (InstanceSpecification) assignmentSource;
if (isComponentInstance(componentInst)) {
assignments.add(a);
}
}
}
}
catch (Exception e) {
continue;
}
}
}
return assignments;
}
/**
* Returns the root instance in the package .
*
* @param thePack is the Package owning the set of InstanceSpecification
* @return the root InstanceSpecification
* //the assumptions are:
* 1) the package owns the InstanceSpecification,
* 2) there is only one root instance in the package,
* 3) the name of a root instances must not contain the '.' character
* 4) the name of a child instance must contain the '.' character (<namespace>.<name of the instance>)
*/
public static InstanceSpecification getRootInstanceInPackage(Package thePack) {
EList<Element> allElems = thePack.allOwnedElements();
String elementName = "";
for (Element elem : allElems) {
if (elem instanceof InstanceSpecification) {
InstanceSpecification instSpec = (InstanceSpecification)elem;
elementName = instSpec.getName();
if (!elementName.contains(".")) {
return instSpec;
}
}
}
return null;
}
/**
* Returns the value of the field identified by the match parameter within the s string
* The s string is expected to be in the form: name1=value1,name2=value2,name3=value3
* with or without surrounding parenthesis.
*
* @param s the s
* @param match the match
* @return the value
*/
public static String getValue(String s, String match) {
if (s== null)
return"";
String found = null;
String[] splits = s.split(",");
for (String split : splits) {
if(split.contains(match)){
String[] ssplits = split.split("=");
for (String str : ssplits) {
if(!str.contains(match)){
found = str;
}
}
}
}
if(found != null){
found = found.trim();
if (found.startsWith("(")){
found = found.substring(1, found.length());
}
if (found.endsWith(")")){
found = found.substring(0, found.length()-1);
}
}
return found;
}
/**
* Returns the response time and unit
* if rldl is expressed in ms by the user convert blockT in ms too
* if rldl is expressed in us by the user convert blockT in us too.
*
* @param rldlUnit the rldl unit
* @param opSaStep the op sa step
* @return the response time string
*/
private static String getResponseTimeString(String rldlUnit, SaStep opSaStep) {
String respT = "";
String respUnit = "";
String respValue ="";
// String rldl = spec.getRlDl();
// String rldlUnit = getValue(rldl, "unit");
if(!opSaStep.getRespT().isEmpty()){
respT = opSaStep.getRespT().get(0);
respUnit = getValue(respT, "unit");
respValue = getValue(respT, "worst");
}
//if rldl is expressed in ms by the user convert blockT in ms too
if(respValue != null && !respValue.isEmpty() && rldlUnit.equals("ms")){
double conv = Float.parseFloat(respValue)*1000;
conv = Math.round(conv*100)/100.0d;
respValue = Double.toString(conv);
respUnit = "ms";
}
//if rldl is expressed in us by the user convert blockT in us too
if(respValue != null && !respValue.isEmpty() && rldlUnit.equals("us")){
double conv = Float.parseFloat(respValue)*1000000;
conv = Math.round(conv*100)/100.0d;
respValue = Double.toString(conv);
respUnit = "us";
}
return respValue + respUnit;
}
/**
* Returns the blocking time and unit
* if rldl is expressed in ms by the user convert blockT in ms too
* if rldl is expressed in us by the user convert blockT in us too.
*
* @param rldlUnit the rldl unit
* @param opSaStep the op sa step
* @return the blocking time string
*/
public static String getBlockingTimeString(String rldlUnit, SaStep opSaStep){
String blockT = "";
String blockUnit = "";
String blockValue ="";
// String rldl = spec.getRlDl();
// String rldlUnit = getValue(rldl, "unit");
blockT = opSaStep.getBlockT();
blockUnit = getValue(blockT, "unit");
blockValue = getValue(blockT, "worst");
//if rldl is expressed in ms by the user convert blockT in ms too
if(blockValue != null && !blockValue.isEmpty() && rldlUnit.equals("ms")){
double conv = Float.parseFloat(blockValue)*1000;
conv = Math.round(conv*100)/100.0d;
blockValue = Double.toString(conv);
blockUnit = "ms";
}
//if rldl is expressed in us by the user convert blockT in us too
if(blockValue != null && !blockValue.isEmpty() && rldlUnit.equals("us")){
double conv = Float.parseFloat(blockValue)*1000000;
conv = Math.round(conv*100)/100.0d;
blockValue = Double.toString(conv);
blockUnit = "us";
}
return blockValue + blockUnit;
}
/**
* Returns the list of AnalysisResultData contained in the PSM Package.
*
* @param contextClass the context class
* @return the analysis results
*/
public static List<AnalysisResultData> getAnalysisResults(Class contextClass){
List<AnalysisResultData> listData = new ArrayList<AnalysisResultData>();
Model model = contextClass.getModel();
Package psm = ViewUtils.getCHESSPSMPackage(model);
if(contextClass.getAppliedStereotype(Constants.MARTE_SaAnalysisContext) == null
){
return listData;
}
String saAnalysisName = contextClass.getQualifiedName();
// SaAnalysisContext saAnalysisCtx = (SaAnalysisContext) contextClass.getStereotypeApplication(contextClass.getAppliedStereotype(Constants.MARTE_SaAnalysisContext));
Package psmPackage;
SaEndtoEndFlow saEndtoEndFlow = null;
SaStep saStep = null;
SaAnalysisContext psmAnalysisContext = null;
for (Package pkg: psm.getNestedPackages()){
Stereotype stereo = pkg.getAppliedStereotype(Constants.CH_PsmPackage);
if(stereo != null){
PSMPackage psmPkg = (PSMPackage) pkg.getStereotypeApplication(stereo);
//the following condition could be done directly comparing the objects and not their names
if(psmPkg.getAnalysisContext().getBase_NamedElement().getQualifiedName().equals(saAnalysisName)){
psmPackage = pkg;
// platform = ((CHGaResourcePlatform) psmPkg.getAnalysisContext().getPlatform().get(0)).getBase_Package();
Slot slot = null;
InstanceSpecification componentInstance = null;
Comment chrtComm = null;
// Activity pimsaEndtoEndFlow = null;
//ASSUMPTION psmPackage owns a AnalysisContext Package
Package psmAnalysisContextPack = (Package) psmPackage.getOwnedMember("AnalysisContext");
Class psmAnalysisContextClass = null;
for (Element elem : psmAnalysisContextPack.getOwnedElements()){
if (!(elem instanceof Class))
continue;
psmAnalysisContextClass = (Class) elem;
psmAnalysisContext = (SaAnalysisContext) psmAnalysisContextClass.getStereotypeApplication(psmAnalysisContextClass.getAppliedStereotype(Constants.MARTE_SaAnalysisContext));
}
for (Element elem: psmAnalysisContextClass.allOwnedElements()){
if (! (elem instanceof Activity))
continue;
Activity activity = (Activity) elem;
if (elem.getAppliedStereotype(Constants.MARTE_EndtoEndFlow) == null)
continue;
psmAnalysisContext = (SaAnalysisContext) psmAnalysisContextClass.getStereotypeApplication(psmAnalysisContextClass.getAppliedStereotype(Constants.MARTE_SaAnalysisContext));
saEndtoEndFlow = (SaEndtoEndFlow) elem.getStereotypeApplication(elem.getAppliedStereotype(Constants.MARTE_EndtoEndFlow));
//assumption: one SaStep inside each SaEndtoEndFlow
for (ActivityNode node: activity.getNodes()){
if (node.getAppliedStereotype(Constants.MARTE_SaStep) == null)
continue;
saStep = (SaStep) node.getStereotypeApplication(node.getAppliedStereotype(Constants.MARTE_SaStep));
//now obtain the link to the originating PIM
//ASSUMPTION: constraints are generated under the contextClass to store information about traceability to PIM
//ASSUMPTION: constrained elements are: SaEndtoEndFlow Activity, ChRtPortSlot Slot or InstanceSpecification, CHRtSpecification Comment.
for (Constraint constr : psmAnalysisContextClass.getOwnedRules()){
if (!constr.getConstrainedElements().contains(activity))
continue;
for (Element constrained : constr.getConstrainedElements()){
if (constrained instanceof Slot)
slot = (Slot) constrained;
if (constrained instanceof Comment)
chrtComm = (Comment) constrained;
if (constrained instanceof InstanceSpecification)
componentInstance = (InstanceSpecification) constrained;
}
}
if (chrtComm == null || (slot == null && componentInstance==null)){
break;
}
//ASSUMPTION chrtComm not null; slot or componentInstance not null
CHRtSpecification chrt = (CHRtSpecification) chrtComm.getStereotypeApplication(chrtComm.getApplicableStereotype(Constants.CHRT_SPECIFICATION));
AnalysisResultData resultData = new AnalysisResultData();
InstanceSpecification inst = (slot!=null ? slot.getOwningInstance() : componentInstance);
resultData.instSpec = inst;
resultData.ctxOP = (Operation) chrt.getContext();
resultData.instance = inst.getName();
resultData.context = chrt.getContext().getName();
ActivityNode initial = activity.getNode("InitialNode1");
Stereotype initialStereo = initial.getAppliedStereotype(Constants.GAWORKLOADEVENT);
GaWorkloadEvent workload = (GaWorkloadEvent) initial.getStereotypeApplication(initialStereo);
resultData.arrival = workload.getPattern();
String rldlValue = "";
String rldlUnit = "";
if(saEndtoEndFlow.getEnd2EndD() != null && !saEndtoEndFlow.getEnd2EndD().isEmpty()){
resultData.rldl = saEndtoEndFlow.getEnd2EndD().get(0);
////
if (resultData.rldl != null) {
rldlValue = getValue(resultData.rldl, "value");
rldlUnit = getValue (resultData.rldl, "unit");
resultData.rldl = rldlValue + rldlUnit;
}
////
}
if(saStep.getConcurRes() != null){
EList<String> schedParams = saStep.getConcurRes().getSchedParams();
if(schedParams != null && !schedParams.isEmpty()){
String schedParam = schedParams.get(0);
resultData.priority = schedParam;
}
}
if(saStep.getSubUsage() != null && !saStep.getSubUsage().isEmpty()){
Operation operation = (Operation) saStep.getSubUsage().get(0).getBase_NamedElement();
SaStep opSaStep = (SaStep) operation.getStereotypeApplication(operation.getAppliedStereotype(Constants.MARTE_SaStep));
if(opSaStep.getExecTime() != null && !opSaStep.getExecTime().isEmpty()){
resultData.localWCET = opSaStep.getExecTime().get(0);
}
resultData.respT = getResponseTimeString(rldlUnit, opSaStep);
resultData.blockT = getBlockingTimeString(rldlUnit, opSaStep);
}
//back propagation run time monitoring
//TODO
if (resultData.respT.isEmpty()){
//TODO assumption: we are in the runtime monitoring case... :(
//try with this...
Stereotype latencyObs = null;
GaLatencyObs obs = null;
for (Constraint constr : activity.getOwnedRules()){
latencyObs = constr.getAppliedStereotype(Constants.GALATENCYOBS);
if (latencyObs != null){
obs = (GaLatencyObs) constr.getStereotypeApplication(latencyObs);
String s = obs.getLatency().get(0);
resultData.respT = s;
}
}
//override exec time
if(saStep.getExecTime() != null && !saStep.getExecTime().isEmpty()){
resultData.localWCET = saStep.getExecTime().get(0);
}
//override blocking time
if(saStep.getBlockT() != null && !saStep.getBlockT().isEmpty()){
resultData.blockT = saStep.getBlockT();
}
}
//end back
// String rldl = chrt.getRlDl();
// String rldlValue = getValue(rldl, "value");
// String rldlUnit = getValue (rldl, "unit");
// resultData.rldl = rldlValue + rldlUnit;
String respT = "";
String respValue ="";
String respUnit ="";
if (saEndtoEndFlow.getEnd2EndT().size()>0){
respT = saEndtoEndFlow.getEnd2EndT().get(0);
respValue = getValue(respT, "worst");
}
//if rldl is expressed in ms by the user convert respT in ms too
if(respValue != null && !respValue.isEmpty() && rldlUnit.equals("ms")){
double conv = Float.parseFloat(respValue)*1000;
conv = Math.round(conv*100)/100.0d;
respValue = Double.toString(conv);
respUnit = "ms";
}
//if rldl is expressed in us by the user convert respT in us too
if(respValue != null && !respValue.isEmpty() && rldlUnit.equals("us")){
double conv = Float.parseFloat(respValue)*1000000;
conv = Math.round(conv*100)/100.0d;
respValue = Double.toString(conv);
respUnit = "us";
}
String responseTime = respValue + respUnit;
if (!respValue.isEmpty() && !rldlValue.isEmpty() ){
if(Float.parseFloat(respValue) <= Float.parseFloat(rldlValue)){
resultData.isSched= "YES";
}else{
resultData.isSched= "NO";
}
}
listData.add(resultData);
}
}
}
}
}
return listData;
}
/**
* Returns the HW results for Schedulability analysis.
*
* @param contextClass the context class
* @return the HW analysis results
*/
public static List<HWAnalysisResultData> getHWAnalysisResults(Class contextClass){
List<HWAnalysisResultData> listData = new ArrayList<HWAnalysisResultData>();
Model model = contextClass.getModel();
Package psm = ViewUtils.getCHESSPSMPackage(model);
if(contextClass.getAppliedStereotype(Constants.MARTE_SaAnalysisContext) == null
){
return listData;
}
String saAnalysisName = contextClass.getQualifiedName();
Package psmPackage;
SaExecHost host = null;
for (Package pkg: psm.getNestedPackages()){
Stereotype stereo = pkg.getAppliedStereotype(Constants.CH_PsmPackage);
if(stereo != null){
PSMPackage psmPkg = (PSMPackage) pkg.getStereotypeApplication(stereo);
System.out.println("Pkg QN="+psmPkg.getAnalysisContext().getBase_NamedElement().getQualifiedName());
if(psmPkg.getAnalysisContext().getBase_NamedElement().getQualifiedName().equals(saAnalysisName)){
psmPackage = pkg;
//ASSUMPTION psmPackage owns a AnalysisContext Package
Package psmHostPack = (Package) psmPackage.getOwnedMember("Host");
for (Element elem: psmHostPack.getOwnedElements()){
if (elem.getAppliedStereotype(Constants.MARTE_SaExecHost) == null)
continue;
host = (SaExecHost) elem.getStereotypeApplication(elem.getAppliedStereotype(Constants.MARTE_SaExecHost));
HWAnalysisResultData data = new HWAnalysisResultData();
data.hw_instance = ((Class) elem).getName();
if (host.getUtilization().size()>0){
data.hw_utilization = host.getUtilization().get(0);
}
listData.add(data);
}
}
}
}
return listData;
}
/**
* Gets the endto end analysis results.
*
* @param contextClass <<SaAnalysisContext>> entity used to perform the end to end response time analysis
* @return get analysis results data for end to end sequence scenarios attached to the given contextClass
*/
public static List<EndToEndResultData> getEndtoEndAnalysisResults(Class contextClass){
List<EndToEndResultData> listData = new ArrayList<EndToEndResultData>();
Model model = contextClass.getModel();
Package psm = ViewUtils.getCHESSPSMPackage(model);
if(contextClass.getAppliedStereotype(Constants.MARTE_SaAnalysisContext) == null
){
return listData;
}
String saAnalysisName = contextClass.getQualifiedName();
Package psmPackage;
for (Package pkg: psm.getNestedPackages()){
Stereotype stereo = pkg.getAppliedStereotype(Constants.CH_PsmPackage);
if(stereo != null){
PSMPackage psmPkg = (PSMPackage) pkg.getStereotypeApplication(stereo);
if(psmPkg.getAnalysisContext().getBase_NamedElement().getQualifiedName().equals(saAnalysisName)){
psmPackage = pkg;
//ASSUMPTION psmPackage owns a AnalysisContext Package
Package psmAnalysisContextPack = (Package) psmPackage.getOwnedMember("AnalysisContext");
Class psmAnalysisContextClass = null;
for (Element temp : psmAnalysisContextPack.getOwnedElements()){
if (!(temp instanceof Class))
continue;
psmAnalysisContextClass = (Class) temp;
for (Element elem: psmAnalysisContextClass.allOwnedElements()){
if (! (elem instanceof Activity))
continue;
Activity activity = (Activity) elem;
if (elem.getAppliedStereotype(Constants.MARTE_EndtoEndFlow) == null)
continue;
//check if the the current PSM endToEndFlow activity refers to a PIM endToEndFlow
SaEndtoEndFlow pimEndtoEndFlow = null;
//check for the constraint that binds the current endToEndFlow activity to the PIM entities
for (Constraint constr : psmAnalysisContextClass.getOwnedRules()){
if (!constr.getConstrainedElements().contains(activity))
continue;
for (Element constrained : constr.getConstrainedElements()){
if (constrained instanceof Activity){
if (constrained != activity){
if (constrained.getAppliedStereotype(Constants.MARTE_EndtoEndFlow) != null &&
constrained.getAppliedStereotype(Constants.GAWORKLOADBEHAVIOR) != null){
pimEndtoEndFlow = (SaEndtoEndFlow) constrained.getStereotypeApplication(constrained.getAppliedStereotype(Constants.MARTE_EndtoEndFlow));
break;
}
}
}
}
if (pimEndtoEndFlow!= null)
break;
}
if (pimEndtoEndFlow!= null){
SaEndtoEndFlow psmEndtoEndFlow = (SaEndtoEndFlow) activity.getStereotypeApplication(activity.getAppliedStereotype(Constants.MARTE_EndtoEndFlow));
EndToEndResultData data = new EndToEndResultData();
data.scenarioName = activity.getName();
if (pimEndtoEndFlow.getEnd2EndD().size()>0) {
data.deadline = pimEndtoEndFlow.getEnd2EndD().get(0);
}
if (psmEndtoEndFlow.getEnd2EndT().size()>0) {
data.respTime = psmEndtoEndFlow.getEnd2EndT().get(0);
}
listData.add(data);
}
}
}
}
}
}
return listData;
}
/**
* <pre>
* Get the selected element, the first selected element if several are selected or null
* if no selection or the selection is not an {@link EObject}.
*
* @return selected {@link EObject} or null
* </pre>
*
*/
public static EObject getSelectedElement() {
EObject eObject = null;
Object selection = null;
IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (activeWorkbenchWindow != null) {
// Get current selection
selection = activeWorkbenchWindow.getSelectionService().getSelection();
// Get first element if the selection is an IStructuredSelection
if (selection instanceof IStructuredSelection) {
IStructuredSelection structuredSelection = (IStructuredSelection) selection;
selection = structuredSelection.getFirstElement();
}
// Treat non-null selected object (try to adapt and return EObject)
if (selection != null) {
if (selection instanceof IAdaptable) {
selection = EMFHelper.getEObject(selection);
}
Object businessObject = BusinessModelResolver.getInstance().getBusinessModel(selection);
if (businessObject instanceof EObject) {
eObject = (EObject) businessObject;
}
}
}
return eObject;
}
/**
* <pre>
* Get the selected element, the first selected element if several are selected or null
* if no selection or the selection is not an {@link EObject}.
*
* @return selected {@link EObject} or null
* </pre>
*
*/
public static EList<EObject> getTwoSelectedElements() {
EObject eObject1 = null;
EObject eObject2 = null;
Object selection = null;
Object selection1 = null;
Object selection2 = null;
EList<EObject> result = new BasicEList<EObject>();
IWorkbenchWindow activeWorkbenchWindow = PlatformUI.getWorkbench().getActiveWorkbenchWindow();
if (activeWorkbenchWindow != null) {
// Get current selection
selection = activeWorkbenchWindow.getSelectionService().getSelection();
// Get first element if the selection is an IStructuredSelection
if (selection instanceof IStructuredSelection) {
IStructuredSelection structuredSelection = (IStructuredSelection) selection;
if (structuredSelection.size()!=2) {
// it will return null because two elements must be selected
return result;
}
Iterator iterator = structuredSelection.iterator();
if (iterator.hasNext()) {
selection1 = iterator.next();
}
if (iterator.hasNext()) {
selection2 = iterator.next();
}
}
// Treat non-null selected object (try to adapt and return EObject)
if (selection1 != null) {
if (selection1 instanceof IAdaptable) {
selection1 = EMFHelper.getEObject(selection1);
}
Object businessObject1 = BusinessModelResolver.getInstance().getBusinessModel(selection1);
if (businessObject1 instanceof EObject) {
eObject1 = (EObject) businessObject1;
}
}
result.add(eObject1);
if (selection2 != null) {
if (selection2 instanceof IAdaptable) {
selection2 = EMFHelper.getEObject(selection2);
}
Object businessObject2 = BusinessModelResolver.getInstance().getBusinessModel(selection2);
if (businessObject2 instanceof EObject) {
eObject2 = (EObject) businessObject2;
}
}
result.add(eObject2);
}
return result;
}
/**
* Returns a list of the NFPValues (value and unit) of the toSearch field,
* or [value=-1.0, unit=] if the field is not present in the string that is parsed.
*
* @param str The string to be parsed.
* @param toSearch Name of the field whose value and unit are to be returned
* @return the all nfp values
*/
public static List<ValueNFP> getAllNfpValues(String str, String toSearch) {
List<ValueNFP> result = new ArrayList<ValueNFP>();
String[] array = str.split("[()=, ]");
for(int i=0; i<array.length-1; i++) {
if (array[i].equalsIgnoreCase(toSearch)) {
for(int j=i+1; j<array.length; j++) {
if(array[j].equalsIgnoreCase("value")) {
String d = array[j+1];
ValueNFP res = new ValueNFP();
res.value = Double.valueOf(d.trim());
for(int k=j+1; k<array.length; k++) {
if(array[k].equalsIgnoreCase("unit")) {
res.unit = array[k+1].trim();
result.add(res);
break;
}
}
break;
}
}
}
}
return result;
}
/**
* Returns the NFPValue (value and unit) of the toSearch field,
* or [value=-1.0, unit=] if the field is not present in the string that is parsed.
*
* @param str The string to be parsed.
* @param toSearch Name of the field whose value and unit are to be returned
* @return the nfp value
*/
public static ValueNFP getNfpValue(String str, String toSearch) {
ValueNFP res = new ValueNFP();
String[] array = str.split("[()=, ]");
for(int i=0; i<array.length-1; i++) {
for(int j=i+1; j<array.length; j++) {
if(array[i].equalsIgnoreCase(toSearch) && array[j].equalsIgnoreCase("value")) {
String d = array[j+1];
res.value = Double.valueOf(d.trim());
for(int k=i+1; k<array.length; k++) {
if(array[k].equalsIgnoreCase("unit")) {
res.unit = array[k+1].trim();
break;
}
}
return res;
}
}
}
res.value = -1.0;
res.unit = "";
return res;
}
/**
* Adds the field named in toSearch with its value and unit to the input NFPValue string
* if it was not there. Otherwise it updates its value and unit.
*
* @param str The NFPValue string to be updated
* @param toSearch The name of the field
* @param value The value to be set
* @param units The unit to be set
* @return the string
*/
public static String setNfpValue(String str, String toSearch, Double value, String units) {
String res = new String();
String toBeAdded = toSearch + "=(value=" + value.toString() + ", unit=" + units + ")";
// empty NFP
if(str == null || str.isEmpty() || str.trim().matches("\\(( *)\\)") )
{
res = "(" + toBeAdded + ")";
return res;
}
// property has already another value specified
if( str.contains(toSearch) )
{
res = str.replaceFirst(toSearch + "( *)=( *)\\((.[^\\)]*)\\)", toBeAdded);
}
else //otherwise
{
int index = str.lastIndexOf(')');
res = str.substring(0, index) + ", " + toBeAdded + str.substring(index);
}
return res;
}
/**
* Returns the first NFPValue (value, unit) found in the input string .
*
* @param value The string to be parsed
* @return the value NFP
*/
public static ValueNFP getValueNFP(String value) {
ValueNFP res = new ValueNFP();
res.value = -1.0;
res.unit = "";
String[] array = value.split("[()=,]");
for(int i=0; i<array.length-1; i++) {
if(array[i].trim().equalsIgnoreCase("value")) {
String d = array[i+1].trim();
res.value = Double.valueOf(d);
}
}
for(int i=0; i<array.length-1; i++) {
if(array[i].trim().equalsIgnoreCase("unit")) {
res.unit = array[i+1].trim();
}
}
return res;
}
/**
* Converts into seconds .
*
* @param value The value to be converted
* @param units The unit in which the value to be converted is originally expressed
* @return The Double value in seconds
*/
public static Double toSeconds(Double value, String units)
{
Double res = value;
if(units == null|| units.trim().equalsIgnoreCase("s"))
res *= 1.0;
else if(units.trim().equalsIgnoreCase("ms"))
res *= 1e-3;
else if(units.trim().equalsIgnoreCase("us"))
res *= 1e-6;
else if(units.trim().equalsIgnoreCase("ns"))
res *= 1e-9;
else if(units.trim().equalsIgnoreCase("min"))
res *= 60;
else if(units.trim().equalsIgnoreCase("hrs"))
res *= 360;
else if(units.trim().equalsIgnoreCase("dys"))
res *= 360 * 24;
return res;
}
/**
* Returns the CHRTSpecification of the ARINCProcess owning the ARINCFunction referred by the given CHRtSpecification (context field) .
*
* @param instSpec the inst spec
* @param arincFunctionSpec the CHRtSpecification referring the ARINCFunction
* @return the arinc process specification
* @throws ModelError the model error
*/
public static CHRtSpecification getArincProcessSpecification(InstanceSpecification instSpec, CHRtSpecification arincFunctionSpec)
throws ModelError {
String theArincFunctName = "";
BehavioralFeature behavFeatFromArincFunctSpec = arincFunctionSpec.getContext();
if (behavFeatFromArincFunctSpec.getAppliedStereotype(Constants.CH_ARINCFunction)!=null) {
Stereotype arincFunctionStereo = behavFeatFromArincFunctSpec.getAppliedStereotype(Constants.CH_ARINCFunction);
ARINCFunction arincFunction = (ARINCFunction) behavFeatFromArincFunctSpec.getStereotypeApplication(arincFunctionStereo);
theArincFunctName = ((NamedElement) arincFunction.getBase_Operation()).getName();
}
else {
throw new ModelError("Error: the input arincFunctionSpec has a context that is not an ARINCFunction");
}
//instance.getPOrtSlots
EList<Slot> slotList = instSpec.getSlots();
for (Slot slot : slotList) {
//look at all the chrtspecifications of the port slot
if (slot.getAppliedStereotype(Constants.CH_CHRtPortSlot)!=null) {
Stereotype chrtPortSlotStereo = slot.getAppliedStereotype(Constants.CH_CHRtPortSlot);
CHRtPortSlot chrtPortSlot = (CHRtPortSlot) slot.getStereotypeApplication(chrtPortSlotStereo);
EList<CHRtSpecification> chrtspecs = chrtPortSlot.getCH_RtSpecification();
for (CHRtSpecification chrtspec : chrtspecs) {
BehavioralFeature behavFeat = chrtspec.getContext();
if (behavFeat.getAppliedStereotype(Constants.CH_ARINCProcess)!=null ) {
Stereotype arincProcessStereo = behavFeat.getAppliedStereotype(Constants.CH_ARINCProcess);
ARINCProcess arincProcess = (ARINCProcess) behavFeat.getStereotypeApplication(arincProcessStereo);
String opGroupsString = arincProcess.getOperationsGroups();
// if in its OperationGroups it contains the (name of the) ARUNCFunction referred to by arincFunctionSpec
if (opGroupsString!=null && opGroupsString.contains(theArincFunctName)) {
return chrtspec;
}
}
}
}
}
return null;
}
/**
* Returns the CHRtSpecification for an ARINCFunction,
* deriving it from the CHRtSpecification of the related CHRtProcess
* and the occurrencyKind of the ARINCFunction itself.
*
* @param instance The InstanceSpecification instance of ARINCComponentImpl owning the given ARINCFunction
* @param arincFunctChrtspec the arinc funct chrtspec
* @return the updated arinc fun chrt spec
* @throws ModelError the model error
*/
public static CHRtSpecification getUpdatedArincFunChrtSpec (InstanceSpecification instance,
CHRtSpecification arincFunctChrtspec) throws ModelError {
CHRtSpecification arincProcessChrtspec = getArincProcessSpecification(instance, arincFunctChrtspec);
if (arincProcessChrtspec == null){
CHESSProjectSupport.printlnToCHESSConsole("ERROR: Unable to retrieve the ARICProcess from the ARINCFunction "+arincFunctChrtspec);
return null;
}
CHRtSpecification chrtspec = arincFunctChrtspec;
String occurrencyKindArincProc = arincProcessChrtspec.getOccKind();
String occurrencyKindArincFunct = arincFunctChrtspec.getOccKind();
//clean the ArincFunction occKind if necessary
if (occurrencyKindArincFunct.contains(Constants.CHRTSPEC_OCCKIND_PERIODIC) || occurrencyKindArincFunct.contains(Constants.CHRTSPEC_OCCKIND_SPORADIC)){
occurrencyKindArincFunct = "("+occurrencyKindArincFunct.substring(occurrencyKindArincFunct.indexOf("phase"));
}
if (!occurrencyKindArincProc.matches("\\s*periodic\\s*(\\(\\s*period\\s*=\\s*\\(\\s*value\\s*=\\s*(\\w*\\.?\\w*)\\s*,\\s*unit\\s*=\\s*(\\w*\\.?\\w*)\\s*\\)\\s*\\))")) {
// The ARINCProcess must have a CHRtSpecification with occurrencyKind that looks like the following:
// periodic(period=(value=100,unit=ms))
throw new ModelError("Unexpected Occurrency Kind for ARINCProcess: "+occurrencyKindArincProc);
}
String newOccurrencyKind = occurrencyKindArincProc.substring(0, occurrencyKindArincProc.lastIndexOf(")"));
newOccurrencyKind += ","+occurrencyKindArincFunct.substring(1);
//newOccurrencyKind += ")";
//get the rate divider of the ARINCFunction and apply it to derive the actual period of he arinc function
int ratediv = 1;
BehavioralFeature behavFeat = arincFunctChrtspec.getContext();
if (behavFeat.getAppliedStereotype(Constants.CH_ARINCFunction)!=null ) {
Stereotype arincFunctionStereo = behavFeat.getAppliedStereotype(Constants.CH_ARINCFunction);
ARINCFunction arincFunction = (ARINCFunction) behavFeat.getStereotypeApplication(arincFunctionStereo);
ratediv= arincFunction.getRateDivider();
}else{
throw new ModelError("ARINCProcess not found for "+behavFeat);
}
ValueNFP nfp = UMLUtils.getNfpValue(occurrencyKindArincProc, "period");
newOccurrencyKind = UMLUtils.setNfpValue(newOccurrencyKind, "period", nfp.value*ratediv, nfp.unit);
chrtspec.setOccKind(newOccurrencyKind);
return chrtspec;
}
/**
* This function returns the list of all the CHrtSpecifications in the given View of the model.
*
* @param umlModel the uml model
* @param viewName the view name
* @return the all chrt specs
* @throws ModelError the model error
*/
public static EList<CHRtSpecification> getAllChrtSpecs(Model umlModel,
String viewName) throws ModelError {
Package parent = CHESSProfileManager.getViewByStereotype(umlModel,
viewName);
EList<Element> all = parent.allOwnedElements();
EList<CHRtSpecification> chrtSpecs = new BasicEList<CHRtSpecification>();
Stereotype stereo = null;
for (Element element : all) {
if((element.getAppliedStereotype(Constants.CHRT_SPECIFICATION)!=null)) {
stereo = element.getAppliedStereotype(Constants.CHRT_SPECIFICATION);
EObject eobj = element.getStereotypeApplication(stereo);
CHRtSpecification chrtSpecification = (CHRtSpecification)eobj;
chrtSpecs.add (chrtSpecification);
}
}
return chrtSpecs;
}
/**
* Checks that the Context has two CHGaResourcePlatforms specified in the Platform field,
* one must be in the ComponentView and one in the DeploymentView,
* the one in the DeploymentView must contain a CH_HWProcessor.
*
* @param saAnalysisContext the sa analysis context
* @param umlModel the uml model
* @return true if the Context points to a SW and a HW instance in the Platform field
*/
public static boolean checkPlatformsInContext(SaAnalysisContext saAnalysisContext, Model umlModel) {
boolean result = false;
EList<GaResourcesPlatform> thePlatforms = saAnalysisContext.getPlatform();
int count = 0;
int countInDeploymentView = 0;
int countInComponentView = 0;
for (GaResourcesPlatform thePlatform : thePlatforms) {
if (thePlatform instanceof CHGaResourcePlatform) {
count++;
}
Package instancePkg = ((CHGaResourcePlatform) thePlatform).getBase_Package();
EList<Package> owningPkgs = instancePkg.allOwningPackages();
for (Package pack : owningPkgs) {
if (pack.equals(CHESSProfileManager.getViewByStereotype(umlModel, Constants.DEPLOYMENT_VIEW_NAME))) {
countInDeploymentView++;
}
else {
if (pack.equals(CHESSProfileManager.getViewByStereotype(umlModel, Constants.COMPONENT_VIEW_NAME))) {
countInComponentView++;
}
}
}
}
if (count==2 && countInDeploymentView==1 && countInComponentView==1) {
result = true;
}
return result;
}
/**
* Checks that at least one Partition or Task is allocated on a Core that is owned by one of the HW instances in input.
*
* @param chHwProcList the ch hw proc list
* @param umlModel the uml model
* @return true if Checks that at least one Partition or Task is allocated on a Core that is owned by one of the HW instances in input
* @throws ModelError the model error
*/
public static boolean checkAllocationToCores(List<CH_HwProcessor> chHwProcList, Model umlModel) throws ModelError {
boolean result = false;
// Look for assignments that involve one of the HW system instances in input
for (CH_HwProcessor chHwProc : chHwProcList) {
EList<Assign> all2CoresAssignments = getAll2CoreAssignments(umlModel, Constants.DEPLOYMENT_VIEW_NAME);
for (Assign assignment : all2CoresAssignments) {
EList<Element> destinations = assignment.getTo();
for (Element assignmentTarget : destinations) {
if (elementIsProcessorInstance(assignmentTarget)) {
Stereotype chHwProcStereo = assignmentTarget.getAppliedStereotype(Constants.CH_HWPROCESSOR);
CH_HwProcessor theAssignmentChHwProc = (CH_HwProcessor) assignmentTarget.getStereotypeApplication(chHwProcStereo);
if (chHwProc.equals(theAssignmentChHwProc)) {
return true;
}
}
}
}
}
return result;
}
}