use of org.osate.aadl2.EventDataPort in project VERDICT by ge-high-assurance.
the class Aadl2Vdm method translateAbstractTypeObjects.
// End of translateDeviceTypeObjects
/**
* Analyzing each abstractType:
* 1. Determine if it is a lower-level system or higher-level system
* 2. If lower-level, add to componentType list attribute of Model
* 2.1 Populate the port, contract, cyberRel, safetyRel, event, id, compCategory
* fields of componentType of the Model object
* 3. If higher-level, assign to Model
* 3.1 Populate the safetyReq
* cyberReq, mission fields of Model object
* @param abstractTypes
* @param m1
* @return
*/
public Model translateAbstractTypeObjects(List<AbstractType> abstractTypes, Model m1, HashSet<String> dataTypeDecl) {
for (AbstractType absType : abstractTypes) {
// variables for unpacking absType
List<Event> events = new ArrayList<>();
List<CyberMission> missionReqs = new ArrayList<>();
List<CyberRel> cyberRels = new ArrayList<>();
List<SafetyRel> safetyRels = new ArrayList<>();
List<CyberReq> cyberReqs = new ArrayList<>();
List<SafetyReq> safetyReqs = new ArrayList<>();
// a flag to check if a higher -level component has already been found
boolean higher_flag = false;
// unpacking absType
for (AnnexSubclause annex : absType.getOwnedAnnexSubclauses()) {
if (annex.getName().equalsIgnoreCase("verdict")) {
Verdict verdictAnnex = VerdictUtil.getVerdict(annex);
for (Statement statement : verdictAnnex.getElements()) {
if (statement instanceof Event) {
events.add((Event) statement);
} else if (statement instanceof CyberMission) {
missionReqs.add((CyberMission) statement);
} else if (statement instanceof CyberReq) {
cyberReqs.add((CyberReq) statement);
} else if (statement instanceof CyberRel) {
cyberRels.add((CyberRel) statement);
} else if (statement instanceof SafetyReq) {
safetyReqs.add((SafetyReq) statement);
} else if (statement instanceof SafetyRel) {
safetyRels.add((SafetyRel) statement);
}
}
}
}
/**
* For every AbstractType,
* populate the id, name, compCateg, port, event,
* cyberRel, and safetyRel fields of componentType
* and add it to the list of componentType
* of the Model object
*/
if (true) {
// No Filter-- do for all System Types
// to pack the memType as a VDM component
verdict.vdm.vdm_model.ComponentType packComponent = new verdict.vdm.vdm_model.ComponentType();
// Note: Not populating "contract" for now
// ISSUE: There is no getId() function for memoryType
packComponent.setId(absType.getQualifiedName());
// populating "name"
packComponent.setName(absType.getName());
// populating "compCateg"
packComponent.setCompCateg(absType.getCategory().getName());
// get all bus accesses and store them as ports
List<BusAccess> busAccesses = absType.getOwnedBusAccesses();
// checking each busAccess's details and adding it to the port list
for (BusAccess busAccess : busAccesses) {
String portName = busAccess.getName();
String modeString = "in";
if (busAccess.getKind() == AccessType.PROVIDES) {
modeString = "providesBusAccess";
} else if (busAccess.getKind() == AccessType.REQUIRES) {
modeString = "requiresBusAccess";
}
verdict.vdm.vdm_model.Port newPort = createVdmPort(portName, modeString, busAccess.getQualifiedName());
// Note: Not populating "type" for now
// ISSUE: "probe", "event", and "id" not found in DataPort class or superclass
// add to port list of component
packComponent.getPort().add(newPort);
}
// End of checking each busAccess
// get all data accesses and store them as ports
List<DataAccess> dataAccesses = absType.getOwnedDataAccesses();
// checking each dataAccess's details and adding it to the port list
for (DataAccess dataAccess : dataAccesses) {
String portName = dataAccess.getName();
String modeString = "in";
if (dataAccess.getKind() == AccessType.PROVIDES) {
modeString = "providesDataAccess";
} else if (dataAccess.getKind() == AccessType.REQUIRES) {
modeString = "requiresDataAccess";
}
verdict.vdm.vdm_model.Port newPort = createVdmPort(portName, modeString, dataAccess.getQualifiedName());
// Note: Not populating "type" for now
// ISSUE: "probe", "event", and "id" not found in DataPort class or superclass
// add to port list of component
packComponent.getPort().add(newPort);
}
// End of checking each dataAccess
// get all ports
List<DataPort> dataPorts = absType.getOwnedDataPorts();
// checking each port's mode and name and adding it to the port list
for (DataPort dataPort : dataPorts) {
verdict.vdm.vdm_model.Port newPort = createVdmPort(dataPort, m1, dataTypeDecl);
// ISSUE: "probe", "event", and "id" not found in DataPort class or superclass
// add to port list of component
packComponent.getPort().add(newPort);
}
// End of checking each port
// get all event data ports
List<EventDataPort> eventDataPorts = absType.getOwnedEventDataPorts();
for (EventDataPort eventDataPort : eventDataPorts) {
verdict.vdm.vdm_model.Port newPort = createVdmPort(eventDataPort, m1, dataTypeDecl);
// add to port list of component
packComponent.getPort().add(newPort);
}
// get all event ports
List<EventPort> eventPorts = absType.getOwnedEventPorts();
for (EventPort eventPort : eventPorts) {
verdict.vdm.vdm_model.Port newPort = createVdmEventPort(eventPort);
// add to port list of component
packComponent.getPort().add(newPort);
}
// packing all events and adding to component
for (Event anEvent : events) {
// To pack the event as a VDM event
verdict.vdm.vdm_model.Event packEvent = createVdmEvent(anEvent);
// adding to the list of component's events
packComponent.getEvent().add(packEvent);
}
// packing all cyberRels and adding to component
for (CyberRel aCyberRel : cyberRels) {
// To pack the cyberRel as a VDM event
verdict.vdm.vdm_model.CyberRel packCyberRel = createVdmCyberRel(aCyberRel);
// adding to the list of component's Cyber relations
packComponent.getCyberRel().add(packCyberRel);
}
// packing all safetyRels and adding to component
for (SafetyRel aSafetyRel : safetyRels) {
// To pack the safetyRel as a VDM event
verdict.vdm.vdm_model.SafetyRel packSafetyRel = createVdmSafetyRel(aSafetyRel);
// adding to the list of component's Safety relations
packComponent.getSafetyRel().add(packSafetyRel);
}
// End of packing all safetyRels
// adding to the list of componenmemTypes of the Model object
m1.getComponentType().add(packComponent);
}
/**
* If a high-level system
* populate the name, safetyReq, cyberReq, and mission
* for the model object
*/
if (!cyberReqs.isEmpty() || !safetyReqs.isEmpty() || !missionReqs.isEmpty()) {
// checking if a high-level system has already been found
if (higher_flag == false) {
higher_flag = true;
} else {
System.out.println("Warning: Multiple high-level systems detected!");
}
// populating name
m1.setName(absType.getName());
// packing all safetyReqs and adding to model
for (SafetyReq aSafetyReq : safetyReqs) {
// To pack the safettReq as a VDM event
verdict.vdm.vdm_model.SafetyReq packSafetyReq = createVdmSafetyReq(aSafetyReq, absType.getFullName());
// adding to the list of model's Safety requirements
m1.getSafetyReq().add(packSafetyReq);
}
// packing all cyberReqs and adding to model
for (CyberReq aCyberReq : cyberReqs) {
// To pack the safettReq as a VDM event
verdict.vdm.vdm_model.CyberReq packCyberReq = createVdmCyberReq(aCyberReq, absType.getFullName());
// adding to the list of model's Cyber requirements
m1.getCyberReq().add(packCyberReq);
}
// packing all missionReqs and adding to model
for (CyberMission aMission : missionReqs) {
// To pack the safettReq as a VDM event
verdict.vdm.vdm_model.Mission packMission = createVdmMission(aMission);
// adding to the list of model's Mission
m1.getMission().add(packMission);
}
// End of packing all missionReqs
}
// End of if a higher-level system
}
// returning the populated Model
return m1;
}
use of org.osate.aadl2.EventDataPort in project VERDICT by ge-high-assurance.
the class Aadl2Vdm method translateComponentImplObjects.
// End of translateProcessorTypeObjects
/**
* Analyzing each component implementation
* @param comImpls
* @param m2
* @return
*/
public Model translateComponentImplObjects(List<ComponentImplementation> comImpls, Map<Property, String> componentPropertyToName, Map<Property, String> connPropertyToName, Model m2, HashSet<String> dataTypeDecl) {
Map<String, String> connectionToBusMap = new HashMap<>();
// creating an object for each implementation first as we will need it later
for (ComponentImplementation aSystemImpl : comImpls) {
// to pack the sysImpl as a VDM componentImpl
verdict.vdm.vdm_model.ComponentImpl packCompImpl = new verdict.vdm.vdm_model.ComponentImpl();
// setting "name" field of packCompImpl, will need later
packCompImpl.setName(aSystemImpl.getName());
// Note: Will skip "Nodebody" field for now
// ISSUE: No "id" field in Component implementations
packCompImpl.setId(aSystemImpl.getQualifiedName());
// adding object to "componentImpl" field of m2
m2.getComponentImpl().add(packCompImpl);
// update map (connection-name -> bus-Instance-Name)
for (PropertyAssociation propAssoc : aSystemImpl.getOwnedPropertyAssociations()) {
if (!(propAssoc.getProperty().getName().equalsIgnoreCase("Actual_Connection_Binding"))) {
System.out.println("System Implementation contains property " + propAssoc.getProperty().getName() + " which is not currently handled.");
continue;
}
if (propAssoc.getOwnedValues().size() != 1) {
throw new RuntimeException("Unexpected number of property owned values: " + propAssoc.getOwnedValues().size());
}
if (!(propAssoc.getOwnedValues().get(0).getOwnedValue() instanceof ListValueImpl)) {
throw new RuntimeException("Unexpected type of property owned value");
} else {
ListValueImpl listVal = (ListValueImpl) propAssoc.getOwnedValues().get(0).getOwnedValue();
if (listVal.getOwnedListElements().size() != 1) {
throw new RuntimeException("Unexpected number of list elements are associated with the property owned value");
} else if (!(listVal.getOwnedListElements().get(0) instanceof ReferenceValueImpl)) {
throw new RuntimeException("Unexpected number of list elements are associated with the property owned value");
} else {
ReferenceValueImpl refVal = (ReferenceValueImpl) listVal.getOwnedListElements().get(0);
ContainmentPathElement pathEle = refVal.getPath();
while (!(pathEle.getNamedElement() instanceof BusSubcomponent)) {
pathEle = pathEle.getPath();
}
String busInstanceName = pathEle.getNamedElement().getQualifiedName();
for (ContainedNamedElement connection : propAssoc.getAppliesTos()) {
// updating map (connection name -> bus name)
connectionToBusMap.put(connection.getPath().getNamedElement().getQualifiedName(), busInstanceName);
}
}
}
}
}
// Getting the reference of the object previously created and populating
for (ComponentImplementation aCompImpl : comImpls) {
// variable to refer to previously created object
verdict.vdm.vdm_model.ComponentImpl packCompImpl = new verdict.vdm.vdm_model.ComponentImpl();
// finding previously created object
for (verdict.vdm.vdm_model.ComponentImpl anImplObj : m2.getComponentImpl()) {
if (anImplObj.getId().equalsIgnoreCase(aCompImpl.getQualifiedName())) {
packCompImpl = anImplObj;
}
}
// setting "type" field of packCompImpl
for (verdict.vdm.vdm_model.ComponentType cType : m2.getComponentType()) {
if (aCompImpl.getType().getQualifiedName().equals(cType.getId())) {
packCompImpl.setType(cType);
}
}
// End of setting "type"
// a BlockImpl object to pack all info for packCompImpl.blockImpl
verdict.vdm.vdm_model.BlockImpl packBlockImpl = new verdict.vdm.vdm_model.BlockImpl();
// adding all subcomponents to "subcomponent" field of packBlockImpl
for (Subcomponent aSubComp : aCompImpl.getOwnedSubcomponents()) {
// to pack all information of a subcomponent
verdict.vdm.vdm_model.ComponentInstance packSubComp = new verdict.vdm.vdm_model.ComponentInstance();
// ISSUE: No "id" field in subcomponents
packSubComp.setId(aSubComp.getQualifiedName());
// setting "name" field of packSubComp
packSubComp.setName(aSubComp.getFullName());
// setting "specification" field of packSubComp
for (verdict.vdm.vdm_model.ComponentType cType : m2.getComponentType()) {
if (aSubComp.getComponentType().getName().equals(cType.getName())) {
packSubComp.setSpecification(cType);
}
}
// setting the "implementation" field of packSubComp
for (verdict.vdm.vdm_model.ComponentImpl cImpl : m2.getComponentImpl()) {
// if(aSubComp.getSubcomponentType().getName().equals(cImpl.getName())){
if (aSubComp.getSubcomponentType().getQualifiedName().equals(cImpl.getId())) {
packSubComp.setImplementation(cImpl);
}
}
// setting "attribute" field of packSubComp
// category of subComponent
String aSubCompCatName = aSubComp.getCategory().getName().toLowerCase();
// checking all collected properties in componentPropertyToName
for (Property prop : componentPropertyToName.keySet()) {
if (isApplicableToCat(prop, aSubCompCatName)) {
// create a GenericAttribute object to pack the property
verdict.vdm.vdm_data.GenericAttribute anAttribute = new verdict.vdm.vdm_data.GenericAttribute();
String value = "";
PropertyAcc propAcc = aSubComp.getPropertyValue(prop);
PropertyExpression defPropExpr = prop.getDefaultValue();
if (propAcc != null && !propAcc.getAssociations().isEmpty()) {
value = getStrRepofPropVal(aSubComp.getPropertyValue(prop));
} else if (defPropExpr != null) {
value = getStrRepofExpr(defPropExpr)[0];
}
if (!value.equals("")) {
// setting the "name" and "value" field of anAttribute
anAttribute.setName(componentPropertyToName.get(prop));
anAttribute.setValue(value);
// get the property type
PropertyType propType = prop.getPropertyType();
QName type = new QName("String");
if (propType instanceof AadlBooleanImpl) {
type = new QName("Bool");
} else if (propType instanceof AadlIntegerImpl) {
type = new QName("Int");
} else if (propType instanceof EnumerationTypeImpl) {
type = new QName("String");
} else {
if (!(propType instanceof AadlStringImpl)) {
type = new QName(propType.toString());
}
}
// parse propertyType fetched using prop.getOwnedPropertyType() and map it to "Bool", "Int", or "String"
anAttribute.setType(type);
// adding asAttribute to packSubComp
packSubComp.getAttribute().add(anAttribute);
}
} else {
// for outer if
continue;
}
}
// adding packSubComp to packBlockImpl
packBlockImpl.getSubcomponent().add(packSubComp);
packCompImpl.setBlockImpl(packBlockImpl);
}
// adding all connections to "connections" field of packBlockImpl
if (aCompImpl.getOwnedConnections() != null && !aCompImpl.getOwnedConnections().isEmpty()) {
for (Connection aConn : aCompImpl.getOwnedConnections()) {
// to pack all information of a connection
verdict.vdm.vdm_model.Connection packConn = new verdict.vdm.vdm_model.Connection();
// populate connectionKind
packConn.setConnectionKind(getConnectionKind(aConn));
// variables to unpack information from AADL object
String srcCompInstName = "";
String destCompInstName = "";
Context srcConnContext = aConn.getAllSourceContext();
Context destConnContext = aConn.getAllDestinationContext();
ConnectionEnd srcConnectionEnd = aConn.getAllSource();
ConnectionEnd destConnectionEnd = aConn.getAllDestination();
if (srcConnContext != null) {
srcCompInstName = srcConnContext.getName();
}
if (destConnContext != null) {
destCompInstName = destConnContext.getName();
}
String srcPortTypeName = "";
String destPortTypeName = "";
String srcPortName = srcConnectionEnd.getName();
String destPortName = destConnectionEnd.getName();
// variables to capture data type information
DataSubcomponentType srcDataSubCompType = null;
DataSubcomponentType destDataSubCompType = null;
if (srcConnectionEnd instanceof DataPort) {
srcPortTypeName = ((DataPort) srcConnectionEnd).isIn() ? (((DataPort) srcConnectionEnd).isOut() ? "inOut" : "in") : "out";
srcDataSubCompType = ((DataPort) srcConnectionEnd).getDataFeatureClassifier();
} else if (srcConnectionEnd instanceof EventDataPort) {
srcPortTypeName = ((EventDataPort) srcConnectionEnd).isIn() ? (((EventDataPort) srcConnectionEnd).isOut() ? "inOut" : "in") : "out";
srcDataSubCompType = ((EventDataPort) srcConnectionEnd).getDataFeatureClassifier();
} else if (srcConnectionEnd instanceof DataAccess) {
AccessType type = ((DataAccess) srcConnectionEnd).getKind();
if (type == AccessType.PROVIDES) {
srcPortTypeName = "providesDataAccess";
} else if (type == AccessType.REQUIRES) {
srcPortTypeName = "requiresDataAccess";
} else {
throw new RuntimeException("Unexpected access type: " + type);
}
srcDataSubCompType = ((DataAccess) srcConnectionEnd).getDataFeatureClassifier();
} else if (srcConnectionEnd instanceof DataSubcomponent) {
srcDataSubCompType = ((DataSubcomponent) srcConnectionEnd).getDataSubcomponentType();
srcPortTypeName = "data";
} else if (srcConnectionEnd instanceof BusAccess) {
// AccessType type = ((BusAccess) srcConnectionEnd).getKind();
// if(type == AccessType.PROVIDES) {
// srcPortTypeName = "providesBusAccess";
// } else if(type == AccessType.REQUIRES) {
// srcPortTypeName = "requiresBusAccess";
// } else {
// throw new RuntimeException("Unexpected access type: " + type);
// }
// BusFeatureClassifier busfeatureClassifier = ((BusAccess) srcConnectionEnd).getBusFeatureClassifier();
// if(busfeatureClassifier instanceof BusImplementation) {
// srcBusImpl = (BusImplementation)busfeatureClassifier;
// }
System.out.println("Warning: Unsupported AADL component element type: " + srcConnectionEnd);
continue;
} else if (srcConnectionEnd instanceof BusSubcomponent) {
// srcBusSubCompType = ((BusSubcomponent)srcConnectionEnd).getBusSubcomponentType();
// srcPortTypeName = "bus";
System.out.println("Warning: Unsupported AADL component element type: " + srcConnectionEnd);
continue;
} else if (srcConnectionEnd instanceof EventPort) {
srcPortTypeName = ((EventPort) srcConnectionEnd).isIn() ? (((EventPort) srcConnectionEnd).isOut() ? "inOut" : "in") : "out";
} else {
throw new RuntimeException("Unsupported AADL component element type: " + srcConnectionEnd + "encountered while processing connections");
}
if (destConnectionEnd instanceof DataPort) {
destPortTypeName = ((DataPort) destConnectionEnd).isIn() ? (((DataPort) destConnectionEnd).isOut() ? "inOut" : "in") : "out";
destDataSubCompType = ((DataPort) destConnectionEnd).getDataFeatureClassifier();
} else if (destConnectionEnd instanceof EventDataPort) {
destPortTypeName = ((EventDataPort) destConnectionEnd).isIn() ? (((EventDataPort) destConnectionEnd).isOut() ? "inOut" : "in") : "out";
destDataSubCompType = ((EventDataPort) destConnectionEnd).getDataFeatureClassifier();
} else if (destConnectionEnd instanceof DataAccess) {
AccessType type = ((DataAccess) destConnectionEnd).getKind();
if (type == AccessType.PROVIDES) {
destPortTypeName = "providesDataAccess";
} else if (type == AccessType.REQUIRES) {
destPortTypeName = "requiresDataAccess";
}
destDataSubCompType = ((DataAccess) destConnectionEnd).getDataFeatureClassifier();
} else if (destConnectionEnd instanceof DataSubcomponent) {
destDataSubCompType = ((DataSubcomponent) destConnectionEnd).getDataSubcomponentType();
destPortTypeName = "data";
} else if (destConnectionEnd instanceof BusAccess) {
// AccessType type = ((BusAccess) destConnectionEnd).getKind();
// if(type == AccessType.PROVIDES) {
// destPortTypeName = "providesBusAccess";
// } else if(type == AccessType.REQUIRES) {
// destPortTypeName = "requiresBusAccess";
// } else {
// throw new RuntimeException("Unexpected access type: " + type);
// }
// BusFeatureClassifier busfeatureClassifier = ((BusAccess) destConnectionEnd).getBusFeatureClassifier();
// if(busfeatureClassifier instanceof BusImplementation) {
// destBusImpl = (BusImplementation)busfeatureClassifier;
// }
System.out.println("Warning: Unsupported AADL component element type: " + destConnectionEnd);
continue;
} else if (destConnectionEnd instanceof BusSubcomponent) {
// destBusSubCompType = ((BusSubcomponent)destConnectionEnd).getBusSubcomponentType();
// destPortTypeName = "bus";
System.out.println("Warning: Unsupported AADL component element type: " + destConnectionEnd);
continue;
} else if (destConnectionEnd instanceof EventPort) {
destPortTypeName = ((EventPort) destConnectionEnd).isIn() ? (((EventPort) destConnectionEnd).isOut() ? "inOut" : "in") : "out";
} else {
throw new RuntimeException("Unsupported AADL component element type: " + destConnectionEnd + "encountered while processing connections");
}
// setting name
packConn.setName(aConn.getFullName());
packConn.setQualifiedName(aConn.getQualifiedName());
if (connectionToBusMap.containsKey(aConn.getQualifiedName())) {
packConn.setActualConnectionBinding(connectionToBusMap.get(aConn.getQualifiedName()));
}
// --- Populate packConn below ---
// to pack source
verdict.vdm.vdm_model.ConnectionEnd packSrcEnd = new verdict.vdm.vdm_model.ConnectionEnd();
// to pack "componentPort" of packSrcEnd
verdict.vdm.vdm_model.Port packSrcEndPort = new verdict.vdm.vdm_model.Port();
// } else
if (srcConnectionEnd instanceof EventPort) {
packSrcEndPort = createVdmConnectionEventPort(srcPortName, srcPortTypeName, srcConnectionEnd.getQualifiedName());
} else {
// if not a bus access port or bus implementation port or event port
packSrcEndPort = createVdmConnectionPort(srcPortName, srcPortTypeName, srcConnectionEnd.getQualifiedName(), srcDataSubCompType, m2, dataTypeDecl);
}
// If source port is independent of a component instance
if (srcCompInstName.equals("")) {
packSrcEnd.setComponentPort(packSrcEndPort);
} else {
// to pack "subcomponentPort" of packSrcEnd
verdict.vdm.vdm_model.CompInstancePort packSrcEndCompInstPort = new verdict.vdm.vdm_model.CompInstancePort();
// putting a reference to appropriate "subcomponent" from packBlockImpl in "subcomponent" of packSrcEndCompInstPort
for (verdict.vdm.vdm_model.ComponentInstance checkCompInst : packBlockImpl.getSubcomponent()) {
if (checkCompInst.getName().equals(srcCompInstName)) {
packSrcEndCompInstPort.setSubcomponent(checkCompInst);
break;
} else {
continue;
}
}
packSrcEndCompInstPort.setPort(packSrcEndPort);
// setting "subcomponentPort" of packSrcEnd
packSrcEnd.setSubcomponentPort(packSrcEndCompInstPort);
}
// adding to "source" of packConn
packConn.setSource(packSrcEnd);
// to pack destination
verdict.vdm.vdm_model.ConnectionEnd packDestEnd = new verdict.vdm.vdm_model.ConnectionEnd();
// to pack "componentPort" of packDestEnd
verdict.vdm.vdm_model.Port packDestEndPort = new verdict.vdm.vdm_model.Port();
// } else
if (destConnectionEnd instanceof EventPort) {
packDestEndPort = createVdmConnectionEventPort(destPortName, destPortTypeName, destConnectionEnd.getQualifiedName());
} else {
// if not a bus access port or bus implementation port or eventport
packDestEndPort = createVdmConnectionPort(destPortName, destPortTypeName, destConnectionEnd.getQualifiedName(), destDataSubCompType, m2, dataTypeDecl);
}
// If source port is independent of a component instance
if (destCompInstName.equals("")) {
packDestEnd.setComponentPort(packDestEndPort);
} else {
// to pack "subcomponentPort" of packSrcEnd
verdict.vdm.vdm_model.CompInstancePort packDestEndCompInstPort = new verdict.vdm.vdm_model.CompInstancePort();
// putting a reference to appropriate "subcomponent" from packBlockImpl in "subcomponent" of packSrcEndCompInstPort
for (verdict.vdm.vdm_model.ComponentInstance checkCompInst : packBlockImpl.getSubcomponent()) {
if (checkCompInst.getName().equals(destCompInstName)) {
packDestEndCompInstPort.setSubcomponent(checkCompInst);
break;
} else {
continue;
}
}
packDestEndCompInstPort.setPort(packDestEndPort);
// setting "subcomponentPort" of packDestEnd
packDestEnd.setSubcomponentPort(packDestEndCompInstPort);
}
// adding to "source" of packConn
packConn.setDestination(packDestEnd);
// adding connection properties from connProperty.ToName
for (Property prop : connPropertyToName.keySet()) {
// create a GenericAttribute object to pack the property
verdict.vdm.vdm_data.GenericAttribute aConnAttribute = new verdict.vdm.vdm_data.GenericAttribute();
String value = "";
PropertyAcc propAcc = aConn.getPropertyValue(prop);
PropertyExpression defPropExpr = prop.getDefaultValue();
if (propAcc != null && !propAcc.getAssociations().isEmpty()) {
value = getStrRepofPropVal(propAcc);
} else if (defPropExpr != null) {
value = getStrRepofExpr(defPropExpr)[0];
}
if (!value.equals("")) {
// setting the "name" and "value" field of anAttribute
aConnAttribute.setName(connPropertyToName.get(prop));
aConnAttribute.setValue(value);
PropertyType propType = prop.getPropertyType();
QName type = new QName("String");
if (propType instanceof AadlBooleanImpl) {
type = new QName("Bool");
} else if (propType instanceof AadlIntegerImpl) {
type = new QName("Int");
} else if (propType instanceof EnumerationTypeImpl) {
type = new QName("String");
} else {
if (!(propType instanceof AadlStringImpl)) {
type = new QName(propType.toString());
}
}
// parse propertyType fetched using prop.getOwnedPropertyType() and map it to "Bool", "Int", or "String"
aConnAttribute.setType(type);
// adding asAttribute to packSubComp
packConn.getAttribute().add(aConnAttribute);
}
}
if (aConn.isBidirectional()) {
packConn.setDirection(verdict.vdm.vdm_model.Direction.fromValue("bidirectional"));
// to pack reverse connection
verdict.vdm.vdm_model.Connection packReverseConn = new verdict.vdm.vdm_model.Connection();
packReverseConn.setName(packConn.getName() + "_reverse");
packReverseConn.setSource(packConn.getDestination());
packReverseConn.setDestination(packConn.getSource());
for (verdict.vdm.vdm_data.GenericAttribute anAttribute : packConn.getAttribute()) {
packReverseConn.getAttribute().add(anAttribute);
}
packReverseConn.setDirection(verdict.vdm.vdm_model.Direction.fromValue("bidirectional"));
// add packReverseConn to packBlockImpl
packBlockImpl.getConnection().add(packReverseConn);
} else {
packConn.setDirection(verdict.vdm.vdm_model.Direction.fromValue("unidirectional"));
}
// add packConn to packBlockImpl
packBlockImpl.getConnection().add(packConn);
packCompImpl.setBlockImpl(packBlockImpl);
}
}
// End of adding all connections
// setting "blackImpl" field of packCompImpl
// packCompImpl.setBlockImpl(packBlockImpl);
}
// return populated Model
return m2;
}
use of org.osate.aadl2.EventDataPort in project VERDICT by ge-high-assurance.
the class Agree2Vdm method getVdmExpressionFromAgreeExpression.
// method to translate expression in Agree to expression in vdm
private Expression getVdmExpressionFromAgreeExpression(Expr agreeExpr, HashSet<String> dataTypeDecl, HashSet<String> nodeDecl, Model model) {
Expression vdmExpr = new Expression();
if (agreeExpr instanceof IfThenElseExpr) {
IfThenElseExpr ifexpr = (IfThenElseExpr) agreeExpr;
// for vdm model
IfThenElse ifThenElseVal = new IfThenElse();
Expression condExpr = getVdmExpressionFromAgreeExpression(ifexpr.getA(), dataTypeDecl, nodeDecl, model);
ifThenElseVal.setCondition(condExpr);
Expression thenBranchExpr = getVdmExpressionFromAgreeExpression(ifexpr.getB(), dataTypeDecl, nodeDecl, model);
ifThenElseVal.setThenBranch(thenBranchExpr);
Expression elseBranchExpr = getVdmExpressionFromAgreeExpression(ifexpr.getC(), dataTypeDecl, nodeDecl, model);
ifThenElseVal.setElseBranch(elseBranchExpr);
vdmExpr.setConditionalExpression(ifThenElseVal);
} else if (agreeExpr instanceof CallExpr) {
CallExpr callExpr = (CallExpr) agreeExpr;
DoubleDotRef ddref = (DoubleDotRef) callExpr.getRef();
if (ddref.getElm() instanceof NodeDef) {
NodeDef nodeDef = (NodeDef) ddref.getElm();
addNodeDefToTypeDeclarations(nodeDef, dataTypeDecl, nodeDecl, model);
// create node call in vdm model
NodeCall vdmNodeCall = new NodeCall();
// setting node name
vdmNodeCall.setNodeId(nodeDef.getName());
EList<Expr> callExprArgs = callExpr.getArgs();
// below are the parameters passed to the function call
for (Expr callExprArg : callExprArgs) {
Expression argExpr = getVdmExpressionFromAgreeExpression(callExprArg, dataTypeDecl, nodeDecl, model);
// setting node arguments
vdmNodeCall.getArgument().add(argExpr);
}
vdmExpr.setCall(vdmNodeCall);
} else {
System.out.println("Unmapped Typed");
}
} else if (agreeExpr instanceof NamedElmExpr) {
NamedElmExpr nmExpr = (NamedElmExpr) agreeExpr;
vdmExpr.setIdentifier(nmExpr.getElm().getName());
// define corresponding types in the VDM if not already defined
if (nmExpr.getElm() instanceof Arg) {
Arg nmElmArg = (Arg) nmExpr.getElm();
// define corresponding type in the VDM if not already defined
Type argType = nmElmArg.getType();
defineDataTypeDataImplementationTypeInVDM(argType, dataTypeDecl, model);
} else if (nmExpr.getElm() instanceof Port) {
Port nmElmPort = (Port) nmExpr.getElm();
// define corresponding type in the VDM if not already defined
if (nmElmPort instanceof DataPortImpl) {
DataPort nmElmDataPort = (DataPort) nmElmPort;
DataSubcomponentType dSubCompType = nmElmDataPort.getDataFeatureClassifier();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
} else if (nmElmPort instanceof EventDataPortImpl) {
EventDataPort nmElmDataPort = (EventDataPort) nmElmPort;
DataSubcomponentType dSubCompType = nmElmDataPort.getDataFeatureClassifier();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
} else {
if (!(nmElmPort instanceof EventPort)) {
System.out.println("Unresolved Port Type");
}
}
} else if (nmExpr.getElm() instanceof ConstStatement) {
ConstStatement nmElmConstStatement = (ConstStatement) nmExpr.getElm();
String nmElmConstStatementName = nmElmConstStatement.getName();
// add const declaration to VDM if not already defined
if (!dataTypeDecl.contains(nmElmConstStatementName)) {
dataTypeDecl.add(nmElmConstStatementName);
ConstantDeclaration vdmConstDeclaration = new ConstantDeclaration();
vdmConstDeclaration.setName(nmElmConstStatementName);
vdmConstDeclaration.setDefinition(getVdmExpressionFromAgreeExpression(nmElmConstStatement.getExpr(), dataTypeDecl, nodeDecl, model));
vdmConstDeclaration.setDataType(getVdmTypeFromAgreeType(nmElmConstStatement.getType(), dataTypeDecl, model));
LustreProgram lustreProgram = model.getDataflowCode();
lustreProgram.getConstantDeclaration().add(vdmConstDeclaration);
model.setDataflowCode(lustreProgram);
}
} else {
System.out.println("Unresolved/unmapped NamedExprElm: " + nmExpr.getElm().getName());
}
} else if (agreeExpr instanceof SelectionExpr) {
// selection expression corresponds to record projection in VDM
RecordProjection vdmRecordProj = new RecordProjection();
SelectionExpr selExpr = (SelectionExpr) agreeExpr;
if (selExpr.getField() == null) {
System.out.println("Null Selection Expr field: " + selExpr.getField());
} else {
NamedElement field = selExpr.getField();
// set record-projection's reference
if (selExpr.getTarget() != null) {
// target can be NamedElmExpr or a SelectionExpr
vdmRecordProj.setRecordReference(getVdmExpressionFromAgreeExpression(selExpr.getTarget(), dataTypeDecl, nodeDecl, model));
}
// set record-projection's field id
vdmRecordProj.setFieldId(field.getName());
// also set the name of the field's type as the record-projection's record-type
if (field instanceof DataPortImpl) {
DataPort dport = (DataPort) field;
DataSubcomponentType dSubCompType = dport.getDataFeatureClassifier();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
vdmRecordProj.setRecordType(dSubCompType.getName());
} else if (field instanceof DataSubcomponentImpl) {
DataSubcomponent dSubComp = (DataSubcomponent) field;
DataSubcomponentType dSubCompType = dSubComp.getDataSubcomponentType();
defineDataTypeDataImplementationTypeInVDM(dSubCompType, dataTypeDecl, model);
vdmRecordProj.setRecordType(dSubCompType.getName());
} else if (field instanceof ArgImpl) {
Arg arg = (Arg) field;
Type argType = arg.getType();
defineDataTypeDataImplementationTypeInVDM(argType, dataTypeDecl, model);
if (argType instanceof PrimType) {
vdmRecordProj.setRecordType(getDataTypeName(argType));
} else {
System.out.println("Unresolved Arg Type so not setting record-type in record-projection.");
}
} else {
System.out.println("Unresolved type of field.");
}
}
vdmExpr.setRecordProjection(vdmRecordProj);
} else if (agreeExpr instanceof BinaryExpr) {
BinaryExpr binExpr = (BinaryExpr) agreeExpr;
// for vdm
BinaryOperation binoper = new BinaryOperation();
// set left operand
Expression leftOperand = getVdmExpressionFromAgreeExpression(binExpr.getLeft(), dataTypeDecl, nodeDecl, model);
binoper.setLhsOperand(leftOperand);
// set right operand
Expression rightOperand = getVdmExpressionFromAgreeExpression(binExpr.getRight(), dataTypeDecl, nodeDecl, model);
binoper.setRhsOperand(rightOperand);
// set appropriate operator
String operator = binExpr.getOp();
if (operator.equalsIgnoreCase("->")) {
vdmExpr.setArrow(binoper);
} else if (operator.equalsIgnoreCase("=>")) {
vdmExpr.setImplies(binoper);
} else if (operator.equalsIgnoreCase("and")) {
vdmExpr.setAnd(binoper);
} else if (operator.equalsIgnoreCase("or")) {
vdmExpr.setOr(binoper);
} else if (operator.equalsIgnoreCase("=")) {
vdmExpr.setEqual(binoper);
} else if (operator.equalsIgnoreCase(">")) {
vdmExpr.setGreaterThan(binoper);
} else if (operator.equalsIgnoreCase("<")) {
vdmExpr.setLessThan(binoper);
} else if (operator.equalsIgnoreCase(">=")) {
vdmExpr.setGreaterThanOrEqualTo(binoper);
} else if (operator.equalsIgnoreCase("<=")) {
vdmExpr.setLessThanOrEqualTo(binoper);
} else if (operator.equalsIgnoreCase("+")) {
vdmExpr.setPlus(binoper);
} else if (operator.equalsIgnoreCase("-")) {
vdmExpr.setMinus(binoper);
} else if (operator.equalsIgnoreCase("!=") || operator.equalsIgnoreCase("<>")) {
vdmExpr.setNotEqual(binoper);
} else if (operator.equalsIgnoreCase("/")) {
vdmExpr.setDiv(binoper);
} else if (operator.equalsIgnoreCase("*")) {
vdmExpr.setTimes(binoper);
} else {
System.out.println("Unmapped binary operator: " + operator);
}
} else if (agreeExpr instanceof UnaryExpr) {
UnaryExpr unExpr = (UnaryExpr) agreeExpr;
Expression singleOperand = getVdmExpressionFromAgreeExpression(unExpr.getExpr(), dataTypeDecl, nodeDecl, model);
String operator = unExpr.getOp();
if (operator.equalsIgnoreCase("this")) {
vdmExpr.setCurrent(singleOperand);
} else if (operator.equalsIgnoreCase("not")) {
vdmExpr.setNot(singleOperand);
} else if (operator.equalsIgnoreCase("-")) {
vdmExpr.setNegative(singleOperand);
} else {
System.out.println("Unmapped unary operator.");
}
} else if (agreeExpr instanceof BoolLitExpr) {
BoolLitExpr boolExpr = (BoolLitExpr) agreeExpr;
vdmExpr.setBoolLiteral(boolExpr.getVal().getValue());
} else if (agreeExpr instanceof EnumLitExpr) {
EnumLitExpr enumExpr = (EnumLitExpr) agreeExpr;
// check if elm is DataImplementationImpl or DataTypeImpl -- if yes add definition to type declarations if not already present
DoubleDotRef enumType = enumExpr.getEnumType();
if (enumType.getElm() instanceof DataTypeImpl) {
org.osate.aadl2.DataType aadlDType = (org.osate.aadl2.DataType) enumType.getElm();
resolveAADLDataType(aadlDType, dataTypeDecl, model);
} else {
System.out.println("Unexpected Elm type for EnumLitExpr");
}
vdmExpr.setIdentifier(enumExpr.getValue());
} else if (agreeExpr instanceof PreExpr) {
PreExpr preExpr = (PreExpr) agreeExpr;
Expression expr = getVdmExpressionFromAgreeExpression(preExpr.getExpr(), dataTypeDecl, nodeDecl, model);
vdmExpr.setPre(expr);
} else if (agreeExpr instanceof RecordLitExpr) {
RecordLiteral vdmRecordLiteral = new RecordLiteral();
RecordLitExpr recLitExpr = (RecordLitExpr) agreeExpr;
if (recLitExpr.getRecordType() instanceof DoubleDotRef) {
DoubleDotRef recType = (DoubleDotRef) recLitExpr.getRecordType();
if (recType.getElm().getName() != null) {
// check if elm is DataImplementationImpl -- if yes add definition to type declarations if not already present
if (recType.getElm() instanceof DataImplementation) {
org.osate.aadl2.DataImplementation aadlDImpl = (org.osate.aadl2.DataImplementation) recType.getElm();
resolveAADLDataImplementationType(aadlDImpl, dataTypeDecl, model);
} else {
System.out.println("Unexpected Elm type for EnumLitExpr");
}
// set name of the record literal in the vdm model
vdmRecordLiteral.setRecordType(recType.getElm().getName());
// get args and arg-expr and set them as field identifier and value in the vdm model
EList<NamedElement> recLitArgs = recLitExpr.getArgs();
EList<Expr> recLitArgsExpr = recLitExpr.getArgExpr();
// below are the values set to variable
for (int ind = 0; ind < recLitArgs.size(); ind++) {
FieldDefinition fieldDef = new FieldDefinition();
fieldDef.setFieldIdentifier(recLitArgs.get(ind).getName());
fieldDef.setFieldValue(getVdmExpressionFromAgreeExpression(recLitArgsExpr.get(ind), dataTypeDecl, nodeDecl, model));
// set field definitions in the record literal in the vdm model
vdmRecordLiteral.getFieldDefinition().add(fieldDef);
}
vdmExpr.setRecordLiteral(vdmRecordLiteral);
} else {
System.out.println("Unexpected Literal's Record Type that has null named elm.");
}
} else {
System.out.println("Unresolved or unmapped record literal expression.");
}
} else if (agreeExpr instanceof IntLitExpr) {
IntLitExpr intLitExpr = (IntLitExpr) agreeExpr;
BigInteger bigInt = new BigInteger(intLitExpr.getVal());
vdmExpr.setIntLiteral(bigInt);
} else if (agreeExpr instanceof RealLitExpr) {
RealLitExpr realLitExpr = (RealLitExpr) agreeExpr;
BigDecimal bigDecimal = new BigDecimal(realLitExpr.getVal());
vdmExpr.setRealLiteral(bigDecimal);
} else if (agreeExpr instanceof EventExpr) {
EventExpr eventExpr = (EventExpr) agreeExpr;
if (eventExpr.getPort() != null) {
vdmExpr.setEvent(getVdmExpressionFromAgreeExpression(eventExpr.getPort(), dataTypeDecl, nodeDecl, model));
} else {
System.out.println("EventExpr does not have port infornation.");
}
} else if (agreeExpr instanceof RealCast) {
RealCast realCastExpr = (RealCast) agreeExpr;
vdmExpr.setToReal(getVdmExpressionFromAgreeExpression(realCastExpr.getExpr(), dataTypeDecl, nodeDecl, model));
} else {
System.out.println("Unresolved/umapped agree expr" + agreeExpr.toString());
}
return vdmExpr;
}
use of org.osate.aadl2.EventDataPort in project AGREE by loonwerks.
the class AgreeASTBuilder method getConnectionEndDataClass.
private DataSubcomponentType getConnectionEndDataClass(ConnectionEnd port) {
DataSubcomponentType dataClass = null;
if (port instanceof DataPort) {
DataPort dataPort = (DataPort) port;
dataClass = dataPort.getDataFeatureClassifier();
} else if (port instanceof EventDataPort) {
EventDataPort eventDataPort = (EventDataPort) port;
dataClass = eventDataPort.getDataFeatureClassifier();
} else if (port instanceof DataSubcomponent) {
dataClass = ((DataSubcomponent) port).getDataSubcomponentType();
}
if (dataClass == null) {
AgreeLogger.logWarning("Unable to determine the type of port '" + port + "'");
}
return dataClass;
}
use of org.osate.aadl2.EventDataPort in project AGREE by loonwerks.
the class AgreeASTBuilder method portToAgreeVar.
private void portToAgreeVar(List<AgreeVar> outputs, List<AgreeVar> inputs, FeatureInstance feature, List<AgreeStatement> assumptions, List<AgreeStatement> guarantees) {
Feature dataFeature = feature.getFeature();
NamedElement dataClass;
if (dataFeature instanceof DataPort) {
DataPort dataPort = (DataPort) dataFeature;
dataClass = dataPort.getDataFeatureClassifier();
} else if (dataFeature instanceof EventDataPort) {
EventDataPort eventDataPort = (EventDataPort) dataFeature;
dataClass = eventDataPort.getDataFeatureClassifier();
} else {
dataClass = null;
}
String name = feature.getName();
boolean isEvent = feature.getCategory() == FeatureCategory.EVENT_DATA_PORT || feature.getCategory() == FeatureCategory.EVENT_PORT;
if (isEvent) {
AgreeVar var = new AgreeVar(name + eventSuffix, NamedType.BOOL, feature.getFeature(), feature.getComponentInstance(), feature);
switch(feature.getDirection()) {
case IN:
inputs.add(var);
break;
case OUT:
outputs.add(var);
break;
default:
throw new AgreeException("Unable to reason about bi-directional event port: " + dataFeature.getQualifiedName());
}
}
if (dataClass == null) {
// we do not reason about this type
return;
}
AgreeTypeSystem.TypeDef td = AgreeTypeSystem.inferFromNamedElement(dataFeature);
Type type = symbolTable.updateLustreTypeMap(td);
if (type == null) {
// we do not reason about this type
return;
}
AgreeVar agreeVar = new AgreeVar(name, type, feature.getFeature(), feature.getComponentInstance(), feature);
switch(feature.getDirection()) {
case IN:
inputs.add(agreeVar);
if (dataClass instanceof DataClassifier) {
List<Expr> constraints = getConstraintsFromTypeDef(name, td);
if (!constraints.isEmpty()) {
assumptions.add(getDataClassifierTypePredicate(feature.getName(), constraints, dataFeature));
}
}
break;
case OUT:
outputs.add(agreeVar);
if (dataClass instanceof DataClassifier) {
List<Expr> constraints = getConstraintsFromTypeDef(name, td);
if (!constraints.isEmpty()) {
guarantees.add(getDataClassifierTypePredicate(feature.getName(), constraints, dataFeature));
}
}
break;
default:
throw new AgreeException("Unable to reason about bi-directional event port: " + dataFeature.getQualifiedName());
}
}
Aggregations