Search in sources :

Example 6 with EventDataPort

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;
}
Also used : ArrayList(java.util.ArrayList) Port(verdict.vdm.vdm_model.Port) DataAccess(org.osate.aadl2.DataAccess) DataPort(org.osate.aadl2.DataPort) EventDataPort(org.osate.aadl2.EventDataPort) EventPort(org.osate.aadl2.EventPort) EventDataPort(org.osate.aadl2.EventDataPort) Verdict(com.ge.research.osate.verdict.dsl.verdict.Verdict) CyberRel(com.ge.research.osate.verdict.dsl.verdict.CyberRel) CyberMission(com.ge.research.osate.verdict.dsl.verdict.CyberMission) BusAccess(org.osate.aadl2.BusAccess) CyberReq(com.ge.research.osate.verdict.dsl.verdict.CyberReq) Statement(com.ge.research.osate.verdict.dsl.verdict.Statement) SafetyRel(com.ge.research.osate.verdict.dsl.verdict.SafetyRel) AbstractType(org.osate.aadl2.AbstractType) Event(com.ge.research.osate.verdict.dsl.verdict.Event) SafetyReq(com.ge.research.osate.verdict.dsl.verdict.SafetyReq) AnnexSubclause(org.osate.aadl2.AnnexSubclause)

Example 7 with EventDataPort

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;
}
Also used : LinkedHashMap(java.util.LinkedHashMap) HashMap(java.util.HashMap) SLPort(com.ge.research.osate.verdict.dsl.verdict.SLPort) LPort(com.ge.research.osate.verdict.dsl.verdict.LPort) EventPort(org.osate.aadl2.EventPort) DataPort(org.osate.aadl2.DataPort) Port(verdict.vdm.vdm_model.Port) EventDataPort(org.osate.aadl2.EventDataPort) PropertyType(org.osate.aadl2.PropertyType) Port(verdict.vdm.vdm_model.Port) DataAccess(org.osate.aadl2.DataAccess) DataPort(org.osate.aadl2.DataPort) EventDataPort(org.osate.aadl2.EventDataPort) ThreadSubcomponent(org.osate.aadl2.ThreadSubcomponent) BusSubcomponent(org.osate.aadl2.BusSubcomponent) Subcomponent(org.osate.aadl2.Subcomponent) MemorySubcomponent(org.osate.aadl2.MemorySubcomponent) ThreadGroupSubcomponent(org.osate.aadl2.ThreadGroupSubcomponent) SubprogramSubcomponent(org.osate.aadl2.SubprogramSubcomponent) DeviceSubcomponent(org.osate.aadl2.DeviceSubcomponent) ProcessSubcomponent(org.osate.aadl2.ProcessSubcomponent) SystemSubcomponent(org.osate.aadl2.SystemSubcomponent) AbstractSubcomponent(org.osate.aadl2.AbstractSubcomponent) DataSubcomponent(org.osate.aadl2.DataSubcomponent) VirtualProcessorSubcomponent(org.osate.aadl2.VirtualProcessorSubcomponent) PropertyAcc(org.osate.aadl2.properties.PropertyAcc) ListValueImpl(org.osate.aadl2.impl.ListValueImpl) EventDataPort(org.osate.aadl2.EventDataPort) AccessType(org.osate.aadl2.AccessType) EnumerationTypeImpl(org.osate.aadl2.impl.EnumerationTypeImpl) BusSubcomponent(org.osate.aadl2.BusSubcomponent) ReferenceValueImpl(org.osate.aadl2.impl.ReferenceValueImpl) DataSubcomponentType(org.osate.aadl2.DataSubcomponentType) ContainedNamedElement(org.osate.aadl2.ContainedNamedElement) ComponentImplementation(org.osate.aadl2.ComponentImplementation) PropertyAssociation(org.osate.aadl2.PropertyAssociation) EventPort(org.osate.aadl2.EventPort) PropertyExpression(org.osate.aadl2.PropertyExpression) Property(org.osate.aadl2.Property) Context(org.osate.aadl2.Context) BusAccess(org.osate.aadl2.BusAccess) AadlBooleanImpl(org.osate.aadl2.impl.AadlBooleanImpl) QName(javax.xml.namespace.QName) AadlStringImpl(org.osate.aadl2.impl.AadlStringImpl) ContainmentPathElement(org.osate.aadl2.ContainmentPathElement) Connection(org.osate.aadl2.Connection) AadlIntegerImpl(org.osate.aadl2.impl.AadlIntegerImpl) DataSubcomponent(org.osate.aadl2.DataSubcomponent) ConnectionEnd(org.osate.aadl2.ConnectionEnd)

Example 8 with EventDataPort

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;
}
Also used : BinaryOperation(verdict.vdm.vdm_lustre.BinaryOperation) EventPort(org.osate.aadl2.EventPort) DataPort(org.osate.aadl2.DataPort) Port(org.osate.aadl2.Port) EventDataPort(org.osate.aadl2.EventDataPort) FieldDefinition(verdict.vdm.vdm_lustre.FieldDefinition) ConstantDeclaration(verdict.vdm.vdm_lustre.ConstantDeclaration) SelectionExpr(com.rockwellcollins.atc.agree.agree.SelectionExpr) DataPort(org.osate.aadl2.DataPort) EventDataPort(org.osate.aadl2.EventDataPort) RealCast(com.rockwellcollins.atc.agree.agree.RealCast) RecordProjection(verdict.vdm.vdm_lustre.RecordProjection) DoubleDotRef(com.rockwellcollins.atc.agree.agree.DoubleDotRef) PrimType(com.rockwellcollins.atc.agree.agree.PrimType) CallExpr(com.rockwellcollins.atc.agree.agree.CallExpr) EventDataPort(org.osate.aadl2.EventDataPort) NamedElmExpr(com.rockwellcollins.atc.agree.agree.NamedElmExpr) RecordLiteral(verdict.vdm.vdm_lustre.RecordLiteral) EnumLitExpr(com.rockwellcollins.atc.agree.agree.EnumLitExpr) EventDataPortImpl(org.osate.aadl2.impl.EventDataPortImpl) RecordLitExpr(com.rockwellcollins.atc.agree.agree.RecordLitExpr) UnaryExpr(com.rockwellcollins.atc.agree.agree.UnaryExpr) IfThenElseExpr(com.rockwellcollins.atc.agree.agree.IfThenElseExpr) ConstStatement(com.rockwellcollins.atc.agree.agree.ConstStatement) DataSubcomponentType(org.osate.aadl2.DataSubcomponentType) PreExpr(com.rockwellcollins.atc.agree.agree.PreExpr) EnumLitExpr(com.rockwellcollins.atc.agree.agree.EnumLitExpr) RealLitExpr(com.rockwellcollins.atc.agree.agree.RealLitExpr) EventExpr(com.rockwellcollins.atc.agree.agree.EventExpr) NamedElmExpr(com.rockwellcollins.atc.agree.agree.NamedElmExpr) SelectionExpr(com.rockwellcollins.atc.agree.agree.SelectionExpr) IfThenElseExpr(com.rockwellcollins.atc.agree.agree.IfThenElseExpr) PreExpr(com.rockwellcollins.atc.agree.agree.PreExpr) RecordLitExpr(com.rockwellcollins.atc.agree.agree.RecordLitExpr) BinaryExpr(com.rockwellcollins.atc.agree.agree.BinaryExpr) UnaryExpr(com.rockwellcollins.atc.agree.agree.UnaryExpr) Expr(com.rockwellcollins.atc.agree.agree.Expr) BoolLitExpr(com.rockwellcollins.atc.agree.agree.BoolLitExpr) NodeBodyExpr(com.rockwellcollins.atc.agree.agree.NodeBodyExpr) IntLitExpr(com.rockwellcollins.atc.agree.agree.IntLitExpr) CallExpr(com.rockwellcollins.atc.agree.agree.CallExpr) IntLitExpr(com.rockwellcollins.atc.agree.agree.IntLitExpr) Arg(com.rockwellcollins.atc.agree.agree.Arg) BigInteger(java.math.BigInteger) RealLitExpr(com.rockwellcollins.atc.agree.agree.RealLitExpr) NamedElement(org.osate.aadl2.NamedElement) ArgImpl(com.rockwellcollins.atc.agree.agree.impl.ArgImpl) BoolLitExpr(com.rockwellcollins.atc.agree.agree.BoolLitExpr) NodeDef(com.rockwellcollins.atc.agree.agree.NodeDef) EventExpr(com.rockwellcollins.atc.agree.agree.EventExpr) DataSubcomponentImpl(org.osate.aadl2.impl.DataSubcomponentImpl) EventPort(org.osate.aadl2.EventPort) NodeCall(verdict.vdm.vdm_lustre.NodeCall) DataPortImpl(org.osate.aadl2.impl.DataPortImpl) EventDataPortImpl(org.osate.aadl2.impl.EventDataPortImpl) BinaryExpr(com.rockwellcollins.atc.agree.agree.BinaryExpr) DataImplementation(org.osate.aadl2.DataImplementation) BigDecimal(java.math.BigDecimal) PrimType(com.rockwellcollins.atc.agree.agree.PrimType) DataSubcomponentType(org.osate.aadl2.DataSubcomponentType) Type(com.rockwellcollins.atc.agree.agree.Type) EnumType(verdict.vdm.vdm_data.EnumType) RecordType(verdict.vdm.vdm_data.RecordType) SystemType(org.osate.aadl2.SystemType) ComponentType(verdict.vdm.vdm_model.ComponentType) EList(org.eclipse.emf.common.util.EList) PropertyExpression(org.osate.aadl2.PropertyExpression) Expression(verdict.vdm.vdm_lustre.Expression) LustreProgram(verdict.vdm.vdm_lustre.LustreProgram) DataSubcomponent(org.osate.aadl2.DataSubcomponent) DataTypeImpl(org.osate.aadl2.impl.DataTypeImpl) IfThenElse(verdict.vdm.vdm_lustre.IfThenElse)

Example 9 with EventDataPort

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;
}
Also used : DataPort(org.osate.aadl2.DataPort) EventDataPort(org.osate.aadl2.EventDataPort) DataSubcomponentType(org.osate.aadl2.DataSubcomponentType) DataSubcomponent(org.osate.aadl2.DataSubcomponent) EventDataPort(org.osate.aadl2.EventDataPort)

Example 10 with EventDataPort

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());
    }
}
Also used : DataClassifier(org.osate.aadl2.DataClassifier) Feature(org.osate.aadl2.Feature) DataPort(org.osate.aadl2.DataPort) EventDataPort(org.osate.aadl2.EventDataPort) AgreeTypeSystem(com.rockwellcollins.atc.agree.AgreeTypeSystem) ConnectionType(com.rockwellcollins.atc.agree.analysis.ast.AgreeAADLConnection.ConnectionType) Type(jkind.lustre.Type) NamedType(jkind.lustre.NamedType) FeatureGroupType(org.osate.aadl2.FeatureGroupType) DataSubcomponentType(org.osate.aadl2.DataSubcomponentType) ComponentType(org.osate.aadl2.ComponentType) EnumLitExpr(com.rockwellcollins.atc.agree.agree.EnumLitExpr) IndicesExpr(com.rockwellcollins.atc.agree.agree.IndicesExpr) TimeRiseExpr(com.rockwellcollins.atc.agree.agree.TimeRiseExpr) RecordAccessExpr(jkind.lustre.RecordAccessExpr) FlatmapExpr(com.rockwellcollins.atc.agree.agree.FlatmapExpr) TimeFallExpr(com.rockwellcollins.atc.agree.agree.TimeFallExpr) RealLitExpr(com.rockwellcollins.atc.agree.agree.RealLitExpr) GetPropertyExpr(com.rockwellcollins.atc.agree.agree.GetPropertyExpr) Expr(jkind.lustre.Expr) CastExpr(jkind.lustre.CastExpr) NodeCallExpr(jkind.lustre.NodeCallExpr) TimeOfExpr(com.rockwellcollins.atc.agree.agree.TimeOfExpr) BoolExpr(jkind.lustre.BoolExpr) BinaryExpr(jkind.lustre.BinaryExpr) RealExpr(jkind.lustre.RealExpr) ArrayExpr(jkind.lustre.ArrayExpr) PrevExpr(com.rockwellcollins.atc.agree.agree.PrevExpr) IdExpr(jkind.lustre.IdExpr) TimeExpr(com.rockwellcollins.atc.agree.agree.TimeExpr) FoldRightExpr(com.rockwellcollins.atc.agree.agree.FoldRightExpr) TagExpr(com.rockwellcollins.atc.agree.agree.TagExpr) EventExpr(com.rockwellcollins.atc.agree.agree.EventExpr) LatchedExpr(com.rockwellcollins.atc.agree.agree.LatchedExpr) NamedElmExpr(com.rockwellcollins.atc.agree.agree.NamedElmExpr) FunctionCallExpr(jkind.lustre.FunctionCallExpr) SelectionExpr(com.rockwellcollins.atc.agree.agree.SelectionExpr) IfThenElseExpr(jkind.lustre.IfThenElseExpr) TupleExpr(jkind.lustre.TupleExpr) UnaryExpr(jkind.lustre.UnaryExpr) ArraySubExpr(com.rockwellcollins.atc.agree.agree.ArraySubExpr) IntExpr(jkind.lustre.IntExpr) PreExpr(com.rockwellcollins.atc.agree.agree.PreExpr) RecordLitExpr(com.rockwellcollins.atc.agree.agree.RecordLitExpr) ExistsExpr(com.rockwellcollins.atc.agree.agree.ExistsExpr) FoldLeftExpr(com.rockwellcollins.atc.agree.agree.FoldLeftExpr) RecordUpdateExpr(com.rockwellcollins.atc.agree.agree.RecordUpdateExpr) ForallExpr(com.rockwellcollins.atc.agree.agree.ForallExpr) ArrayAccessExpr(jkind.lustre.ArrayAccessExpr) ArrayUpdateExpr(com.rockwellcollins.atc.agree.agree.ArrayUpdateExpr) BoolLitExpr(com.rockwellcollins.atc.agree.agree.BoolLitExpr) NodeBodyExpr(com.rockwellcollins.atc.agree.agree.NodeBodyExpr) IntLitExpr(com.rockwellcollins.atc.agree.agree.IntLitExpr) CallExpr(com.rockwellcollins.atc.agree.agree.CallExpr) ArrayLiteralExpr(com.rockwellcollins.atc.agree.agree.ArrayLiteralExpr) AgreeException(com.rockwellcollins.atc.agree.analysis.AgreeException) EventDataPort(org.osate.aadl2.EventDataPort) NamedElement(org.osate.aadl2.NamedElement)

Aggregations

EventDataPort (org.osate.aadl2.EventDataPort)43 DataPort (org.osate.aadl2.DataPort)26 EventPort (org.osate.aadl2.EventPort)23 ArrayList (java.util.ArrayList)18 AnnexSubclause (org.osate.aadl2.AnnexSubclause)13 Port (verdict.vdm.vdm_model.Port)13 CyberRel (com.ge.research.osate.verdict.dsl.verdict.CyberRel)12 CyberReq (com.ge.research.osate.verdict.dsl.verdict.CyberReq)12 Event (com.ge.research.osate.verdict.dsl.verdict.Event)12 SafetyRel (com.ge.research.osate.verdict.dsl.verdict.SafetyRel)12 SafetyReq (com.ge.research.osate.verdict.dsl.verdict.SafetyReq)12 CyberMission (com.ge.research.osate.verdict.dsl.verdict.CyberMission)11 Statement (com.ge.research.osate.verdict.dsl.verdict.Statement)11 Verdict (com.ge.research.osate.verdict.dsl.verdict.Verdict)11 NamedElement (org.osate.aadl2.NamedElement)11 BusAccess (org.osate.aadl2.BusAccess)10 DataAccess (org.osate.aadl2.DataAccess)10 DataSubcomponent (org.osate.aadl2.DataSubcomponent)9 DataSubcomponentType (org.osate.aadl2.DataSubcomponentType)6 DoubleDotRef (com.rockwellcollins.atc.agree.agree.DoubleDotRef)5