Examples with BusImplementation org.osate.aadl2.BusImplementation used on opensource projects

Example 1 with BusImplementation

use of org.osate.aadl2.BusImplementation in project VERDICT by ge-high-assurance.

the class Aadl2CsvTranslator method populateDataFromAadlObjects.

/**
 * Assume the input model is correct without any syntax errors
 * Populate mission req, cyber and safety reqs and rels from AADL objects
 */
public void populateDataFromAadlObjects(List<EObject> objects) {
    List<ComponentType> componentTypes = new ArrayList<>();
    for (EObject obj : objects) {
        if (obj instanceof SystemType) {
            componentTypes.add((SystemType) obj);
        } else if (obj instanceof BusType) {
            componentTypes.add((BusType) obj);
        } else if (obj instanceof SubprogramType) {
            componentTypes.add((SubprogramType) obj);
        } else if (obj instanceof ThreadType) {
            componentTypes.add((ThreadType) obj);
        } else if (obj instanceof MemoryType) {
            componentTypes.add((MemoryType) obj);
        } else if (obj instanceof DeviceType) {
            componentTypes.add((DeviceType) obj);
        } else if (obj instanceof AbstractType) {
            componentTypes.add((AbstractType) obj);
        } else if (obj instanceof ProcessType) {
            componentTypes.add((ProcessType) obj);
        } else if (obj instanceof ThreadGroupType) {
            componentTypes.add((ThreadGroupType) obj);
        } else if (obj instanceof VirtualProcessorType) {
            componentTypes.add((VirtualProcessorType) obj);
        } else if (obj instanceof ProcessorType) {
            componentTypes.add((ProcessorType) obj);
        } else if (obj instanceof SystemImplementation) {
            compImpls.add((SystemImplementation) obj);
        } else if (obj instanceof SubprogramImplementation) {
            compImpls.add((SubprogramImplementation) obj);
        } else if (obj instanceof ThreadImplementation) {
            compImpls.add((ThreadImplementation) obj);
        } else if (obj instanceof MemoryImplementation) {
            compImpls.add((MemoryImplementation) obj);
        } else if (obj instanceof BusImplementation) {
            compImpls.add((BusImplementation) obj);
        } else if (obj instanceof AbstractImplementation) {
            compImpls.add((AbstractImplementation) obj);
        } else if (obj instanceof DeviceImplementation) {
            compImpls.add((DeviceImplementation) obj);
        } else if (obj instanceof ProcessImplementation) {
            compImpls.add((ProcessImplementation) obj);
        } else if (obj instanceof ThreadGroupImplementation) {
            compImpls.add((ThreadGroupImplementation) obj);
        } else if (obj instanceof VirtualProcessorImplementation) {
            compImpls.add((VirtualProcessorImplementation) obj);
        } else if (obj instanceof ProcessorImplementation) {
            compImpls.add((ProcessorImplementation) obj);
        } else if (obj instanceof PropertySetImpl) {
            // String propertySetName = ((PropertySetImpl)obj).getName();
            // List<Property> compProps = new ArrayList<Property>();
            Set<Property> compPropSet = new HashSet<Property>();
            // List<Property> connProps = new ArrayList<Property>();
            Set<Property> connPropSet = new HashSet<Property>();
            for (Property prop : ((PropertySetImpl) obj).getOwnedProperties()) {
                // Save property owner to be used later
                for (PropertyOwner po : prop.getAppliesTos()) {
                    String propCat = ((MetaclassReferenceImpl) po).getMetaclass().getName().toLowerCase();
                    String propName = prop.getName();
                    switch(propCat) {
                        case "system":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "thread":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "processor":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "memory":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "connection":
                            {
                                connPropertyToName.put(prop, propName);
                                connPropSet.add(prop);
                                break;
                            }
                        case "process":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "abstract":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "device":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "threadgroup":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "virtualprocessor":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        case "bus":
                            {
                                componentPropertyToName.put(prop, propName);
                                compPropSet.add(prop);
                                break;
                            }
                        default:
                            {
                                System.out.println("Warning: unsupported property applies to: " + propCat);
                                break;
                            }
                    }
                }
            }
        // compProps.addAll(compPropSet);
        // connProps.addAll(connPropSet);
        // propSetNameToCompProps.put(propertySetName, compProps);
        // propSetNameToConnProps.put(propertySetName, connProps);
        }
    }
    for (ComponentType compType : componentTypes) {
        String compTypeName = compType.getName();
        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<>();
        for (AnnexSubclause annex : compType.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);
                    }
                }
            }
        }
        if (!events.isEmpty()) {
            compTypeNameToEvents.put(compTypeName, events);
        }
        if (!missionReqs.isEmpty()) {
            compTypeNameToMissions.put(compTypeName, missionReqs);
        }
        if (!cyberRels.isEmpty()) {
            compTypeNameToCyberRels.put(compTypeName, cyberRels);
        }
        if (!safetyRels.isEmpty()) {
            compTypeNameToSafetyRels.put(compTypeName, safetyRels);
        }
        if (!cyberReqs.isEmpty()) {
            compTypeNameToCyberReqs.put(compTypeName, cyberReqs);
        }
        if (!safetyReqs.isEmpty()) {
            compTypeNameToSafetyReqs.put(compTypeName, safetyReqs);
        }
    }
    for (ComponentImplementation impl : compImpls) {
        compTypeNameToImpl.put(impl.getType().getName(), impl);
        if (!impl.getAllConnections().isEmpty()) {
            sysImplToConns.put(impl, impl.getAllConnections());
        }
    }
}

Example 2 with BusImplementation

use of org.osate.aadl2.BusImplementation in project VERDICT by ge-high-assurance.

the class Aadl2Vdm method populateVDMFromAadlObjects.

/**
 * Assume the input is correct without any syntax errors
 * Populate mission req, cyber and safety reqs and rels from AADL objects
 *
 *  @param objects a List of AADL objects,
 * @param objectsFromFilesInProject
 * 	@param model an empty VDM model to populate
 *  @return a populated VDM model
 * Vidhya: modified function to add and process only objects in the aadl files in the project excluding those in imported aadl files
 */
public Model populateVDMFromAadlObjects(List<EObject> objects, List<EObject> objectsFromFilesInProject, Model model) {
    HashSet<String> dataTypeDecl = new HashSet<String>();
    // variables for extracting data from the AADL object
    List<SystemType> systemTypes = new ArrayList<>();
    List<BusType> busTypes = new ArrayList<>();
    List<SubprogramType> subprogramTypes = new ArrayList<>();
    List<ThreadType> threadTypes = new ArrayList<>();
    List<MemoryType> memoryTypes = new ArrayList<>();
    List<DeviceType> deviceTypes = new ArrayList<>();
    List<AbstractType> abstractTypes = new ArrayList<>();
    List<ProcessType> processTypes = new ArrayList<>();
    List<ThreadGroupType> threadGroupTypes = new ArrayList<>();
    List<VirtualProcessorType> virtualProcessorTypes = new ArrayList<>();
    List<ProcessorType> processorTypes = new ArrayList<>();
    List<ComponentImplementation> compImpls = new ArrayList<>();
    Map<Property, String> connPropertyToName = new LinkedHashMap<>();
    Map<Property, String> componentPropertyToName = new LinkedHashMap<>();
    // process only those properties defined in files in the project and not in the imported files
    HashSet<String> objectNamesFromFilesInProject = getObjectNames(objectsFromFilesInProject);
    // extracting data from the AADLObject
    for (EObject obj : objects) {
        if (obj instanceof SystemType) {
            if (objectNamesFromFilesInProject.contains(((SystemType) obj).getName())) {
                systemTypes.add((SystemType) obj);
            }
        } else if (obj instanceof BusType) {
            if (objectNamesFromFilesInProject.contains(((BusType) obj).getName())) {
                busTypes.add((BusType) obj);
            }
        } else if (obj instanceof SubprogramType) {
            if (objectNamesFromFilesInProject.contains(((SubprogramType) obj).getName())) {
                subprogramTypes.add((SubprogramType) obj);
            }
        } else if (obj instanceof ThreadType) {
            if (objectNamesFromFilesInProject.contains(((ThreadType) obj).getName())) {
                threadTypes.add((ThreadType) obj);
            }
        } else if (obj instanceof MemoryType) {
            if (objectNamesFromFilesInProject.contains(((MemoryType) obj).getName())) {
                memoryTypes.add((MemoryType) obj);
            }
        } else if (obj instanceof DeviceType) {
            if (objectNamesFromFilesInProject.contains(((DeviceType) obj).getName())) {
                deviceTypes.add((DeviceType) obj);
            }
        } else if (obj instanceof AbstractType) {
            if (objectNamesFromFilesInProject.contains(((AbstractType) obj).getName())) {
                abstractTypes.add((AbstractType) obj);
            }
        } else if (obj instanceof ProcessType) {
            if (objectNamesFromFilesInProject.contains(((ProcessType) obj).getName())) {
                processTypes.add((ProcessType) obj);
            }
        } else if (obj instanceof ThreadGroupType) {
            if (objectNamesFromFilesInProject.contains(((ThreadGroupType) obj).getName())) {
                threadGroupTypes.add((ThreadGroupType) obj);
            }
        } else if (obj instanceof VirtualProcessorType) {
            if (objectNamesFromFilesInProject.contains(((VirtualProcessorType) obj).getName())) {
                virtualProcessorTypes.add((VirtualProcessorType) obj);
            }
        } else if (obj instanceof ProcessorType) {
            if (objectNamesFromFilesInProject.contains(((ProcessorType) obj).getName())) {
                processorTypes.add((ProcessorType) obj);
            }
        } else if (obj instanceof SystemImplementation) {
            if (objectNamesFromFilesInProject.contains(((SystemImplementation) obj).getName())) {
                compImpls.add((SystemImplementation) obj);
            }
        } else if (obj instanceof SubprogramImplementation) {
            if (objectNamesFromFilesInProject.contains(((SubprogramImplementation) obj).getName())) {
                compImpls.add((SubprogramImplementation) obj);
            }
        } else if (obj instanceof ThreadImplementation) {
            if (objectNamesFromFilesInProject.contains(((ThreadImplementation) obj).getName())) {
                compImpls.add((ThreadImplementation) obj);
            }
        } else if (obj instanceof MemoryImplementation) {
            if (objectNamesFromFilesInProject.contains(((MemoryImplementation) obj).getName())) {
                compImpls.add((MemoryImplementation) obj);
            }
        } else if (obj instanceof BusImplementation) {
            if (objectNamesFromFilesInProject.contains(((BusImplementation) obj).getName())) {
                compImpls.add((BusImplementation) obj);
            }
        } else if (obj instanceof AbstractImplementation) {
            if (objectNamesFromFilesInProject.contains(((AbstractImplementation) obj).getName())) {
                compImpls.add((AbstractImplementation) obj);
            }
        } else if (obj instanceof DeviceImplementation) {
            if (objectNamesFromFilesInProject.contains(((DeviceImplementation) obj).getName())) {
                compImpls.add((DeviceImplementation) obj);
            }
        } else if (obj instanceof ProcessImplementation) {
            if (objectNamesFromFilesInProject.contains(((ProcessImplementation) obj).getName())) {
                compImpls.add((ProcessImplementation) obj);
            }
        } else if (obj instanceof ThreadGroupImplementation) {
            if (objectNamesFromFilesInProject.contains(((ThreadGroupImplementation) obj).getName())) {
                compImpls.add((ThreadGroupImplementation) obj);
            }
        } else if (obj instanceof VirtualProcessorImplementation) {
            if (objectNamesFromFilesInProject.contains(((VirtualProcessorImplementation) obj).getName())) {
                compImpls.add((VirtualProcessorImplementation) obj);
            }
        } else if (obj instanceof ProcessorImplementation) {
            if (objectNamesFromFilesInProject.contains(((ProcessorImplementation) obj).getName())) {
                compImpls.add((ProcessorImplementation) obj);
            }
        } else if (obj instanceof PropertySetImpl) {
            Set<Property> compPropSet = new HashSet<Property>();
            Set<Property> connPropSet = new HashSet<Property>();
            for (Property prop : ((PropertySetImpl) obj).getOwnedProperties()) {
                // Save property owner to be used later
                for (PropertyOwner po : prop.getAppliesTos()) {
                    String propCat = ((MetaclassReferenceImpl) po).getMetaclass().getName().toLowerCase();
                    String propName = prop.getName();
                    switch(propCat) {
                        case "system":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "thread":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "processor":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "memory":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "connection":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    connPropertyToName.put(prop, propName);
                                }
                                connPropSet.add(prop);
                                break;
                            }
                        case "process":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "abstract":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "device":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "threadgroup":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "virtualprocessor":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "bus":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        case "port":
                            {
                                if (objectNamesFromFilesInProject.contains(propName)) {
                                    componentPropertyToName.put(prop, propName);
                                }
                                compPropSet.add(prop);
                                break;
                            }
                        default:
                            {
                                if (objectNamesFromFilesInProject.contains(((PropertySetImpl) obj).getName())) {
                                    System.out.println("Warning: unsupported property: " + propName + ", applies to: " + propCat);
                                }
                                break;
                            }
                    }
                }
            }
        }
    }
    /* Translating all Component Types */
    if (systemTypes.size() > 0) {
        model = translateSystemTypeObjects(systemTypes, model, dataTypeDecl);
    }
    if (busTypes.size() > 0) {
        model = translateBusTypeObjects(busTypes, model, dataTypeDecl);
    }
    if (subprogramTypes.size() > 0) {
        model = translateSubprogramTypeObjects(subprogramTypes, model, dataTypeDecl);
    }
    if (threadTypes.size() > 0) {
        model = translateThreadTypeObjects(threadTypes, model, dataTypeDecl);
    }
    if (memoryTypes.size() > 0) {
        model = translateMemoryTypeObjects(memoryTypes, model, dataTypeDecl);
    }
    if (deviceTypes.size() > 0) {
        model = translateDeviceTypeObjects(deviceTypes, model, dataTypeDecl);
    }
    if (abstractTypes.size() > 0) {
        model = translateAbstractTypeObjects(abstractTypes, model, dataTypeDecl);
    }
    if (processTypes.size() > 0) {
        model = translateProcessTypeObjects(processTypes, model, dataTypeDecl);
    }
    if (processTypes.size() > 0) {
        model = translateProcessorTypeObjects(processorTypes, model, dataTypeDecl);
    }
    if (threadGroupTypes.size() > 0) {
        model = translateThreadGroupTypeObjects(threadGroupTypes, model, dataTypeDecl);
    }
    if (virtualProcessorTypes.size() > 0) {
        model = translateVirtualProcessorTypeObjects(virtualProcessorTypes, model, dataTypeDecl);
    }
    /* Translating all System Implementations */
    // model = translateSystemImplObjects(systemImpls, componentPropertyToName, connPropertyToName,model);
    // model = translateComponentImplObjects(compImpls, componentPropertyToName, connPropertyToName,model);
    /**
     * Translating all component implementations
     */
    model = translateComponentImplObjects(compImpls, componentPropertyToName, connPropertyToName, model, dataTypeDecl);
    // return the final model
    return model;
}

Example 3 with BusImplementation

use of org.osate.aadl2.BusImplementation 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;
}

Example 4 with BusImplementation

use of org.osate.aadl2.BusImplementation in project VERDICT by ge-high-assurance.

the class Aadl2Vdm method getObjectNames.

/**
 * @author Vidhya Tekken Valapil
 * Fetch names of objects and return the list of names
 */
private HashSet<String> getObjectNames(List<EObject> objects) {
    HashSet<String> objNames = new HashSet<String>();
    for (EObject obj : objects) {
        // process only those objects in files in the project and not in the imported files
        if (obj instanceof SystemType) {
            objNames.add(((SystemType) obj).getName());
        } else if (obj instanceof BusType) {
            objNames.add(((BusType) obj).getName());
        } else if (obj instanceof SubprogramType) {
            objNames.add(((SubprogramType) obj).getName());
        } else if (obj instanceof ThreadType) {
            objNames.add(((ThreadType) obj).getName());
        } else if (obj instanceof MemoryType) {
            objNames.add(((MemoryType) obj).getName());
        } else if (obj instanceof DeviceType) {
            objNames.add(((DeviceType) obj).getName());
        } else if (obj instanceof AbstractType) {
            objNames.add(((AbstractType) obj).getName());
        } else if (obj instanceof ProcessType) {
            objNames.add(((ProcessType) obj).getName());
        } else if (obj instanceof ThreadGroupType) {
            objNames.add(((ThreadGroupType) obj).getName());
        } else if (obj instanceof VirtualProcessorType) {
            objNames.add(((VirtualProcessorType) obj).getName());
        } else if (obj instanceof ProcessorType) {
            objNames.add(((ProcessorType) obj).getName());
        } else if (obj instanceof SystemImplementation) {
            objNames.add(((SystemImplementation) obj).getName());
        } else if (obj instanceof SubprogramImplementation) {
            objNames.add(((SubprogramImplementation) obj).getName());
        } else if (obj instanceof ThreadImplementation) {
            objNames.add(((ThreadImplementation) obj).getName());
        } else if (obj instanceof MemoryImplementation) {
            objNames.add(((MemoryImplementation) obj).getName());
        } else if (obj instanceof BusImplementation) {
            objNames.add(((BusImplementation) obj).getName());
        } else if (obj instanceof AbstractImplementation) {
            objNames.add(((AbstractImplementation) obj).getName());
        } else if (obj instanceof DeviceImplementation) {
            objNames.add(((DeviceImplementation) obj).getName());
        } else if (obj instanceof ProcessImplementation) {
            objNames.add(((ProcessImplementation) obj).getName());
        } else if (obj instanceof ThreadGroupImplementation) {
            objNames.add(((ThreadGroupImplementation) obj).getName());
        } else if (obj instanceof VirtualProcessorImplementation) {
            objNames.add(((VirtualProcessorImplementation) obj).getName());
        } else if (obj instanceof ProcessorImplementation) {
            objNames.add(((ProcessorImplementation) obj).getName());
        } else if (obj instanceof PropertySetImpl) {
            for (Property prop : ((PropertySetImpl) obj).getOwnedProperties()) {
                // Save property owner to be used later
                for (PropertyOwner po : prop.getAppliesTos()) {
                    String propCat = ((MetaclassReferenceImpl) po).getMetaclass().getName().toLowerCase();
                    String propName = prop.getName();
                    switch(propCat) {
                        case "system":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "thread":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "processor":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "memory":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "connection":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "process":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "abstract":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "device":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "threadgroup":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "virtualprocessor":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "bus":
                            {
                                objNames.add(propName);
                                break;
                            }
                        case "port":
                            {
                                objNames.add(propName);
                                break;
                            }
                        default:
                            {
                                System.out.println("Warning: unsupported property: " + propName + ", applies to: " + propCat);
                                break;
                            }
                    }
                }
            }
        }
    }
    return objNames;
}

Example 5 with BusImplementation

use of org.osate.aadl2.BusImplementation in project osate2 by osate.

the class AbstractAadl2SemanticSequencer method sequence.

@Override
public void sequence(ISerializationContext context, EObject semanticObject) {
    EPackage epackage = semanticObject.eClass().getEPackage();
    ParserRule rule = context.getParserRule();
    Action action = context.getAssignedAction();
    Set<Parameter> parameters = context.getEnabledBooleanParameters();
    if (epackage == Aadl2Package.eINSTANCE)
        switch(semanticObject.eClass().getClassifierID()) {
            case Aadl2Package.AADL_BOOLEAN:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getBooleanTypeRule()) {
                    sequence_BooleanType(context, (AadlBoolean) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedBooleanTypeRule()) {
                    sequence_UnnamedBooleanType(context, (AadlBoolean) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.AADL_INTEGER:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getIntegerTypeRule()) {
                    sequence_IntegerType(context, (AadlInteger) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedIntegerTypeRule()) {
                    sequence_UnnamedIntegerType(context, (AadlInteger) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.AADL_PACKAGE:
                sequence_AadlPackage(context, (AadlPackage) semanticObject);
                return;
            case Aadl2Package.AADL_REAL:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getRealTypeRule()) {
                    sequence_RealType(context, (AadlReal) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedRealTypeRule()) {
                    sequence_UnnamedRealType(context, (AadlReal) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.AADL_STRING:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getStringTypeRule()) {
                    sequence_StringType(context, (AadlString) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedStringTypeRule()) {
                    sequence_UnnamedStringType(context, (AadlString) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.ABSTRACT_FEATURE:
                sequence_AbstractFeature(context, (AbstractFeature) semanticObject);
                return;
            case Aadl2Package.ABSTRACT_IMPLEMENTATION:
                sequence_AbstractImplementation(context, (AbstractImplementation) semanticObject);
                return;
            case Aadl2Package.ABSTRACT_PROTOTYPE:
                sequence_AbstractPrototype(context, (AbstractPrototype) semanticObject);
                return;
            case Aadl2Package.ABSTRACT_SUBCOMPONENT:
                sequence_AbstractSubcomponent(context, (AbstractSubcomponent) semanticObject);
                return;
            case Aadl2Package.ABSTRACT_TYPE:
                sequence_AbstractType(context, (AbstractType) semanticObject);
                return;
            case Aadl2Package.ACCESS_CONNECTION:
                sequence_AccessConnection(context, (AccessConnection) semanticObject);
                return;
            case Aadl2Package.ACCESS_SPECIFICATION:
                sequence_AccessSpecification(context, (AccessSpecification) semanticObject);
                return;
            case Aadl2Package.ARRAY_DIMENSION:
                sequence_ArrayDimension(context, (ArrayDimension) semanticObject);
                return;
            case Aadl2Package.ARRAY_RANGE:
                sequence_ArrayRange(context, (ArrayRange) semanticObject);
                return;
            case Aadl2Package.ARRAY_SIZE:
                sequence_ArraySize(context, (ArraySize) semanticObject);
                return;
            case Aadl2Package.BASIC_PROPERTY:
                sequence_RecordField(context, (BasicProperty) semanticObject);
                return;
            case Aadl2Package.BASIC_PROPERTY_ASSOCIATION:
                sequence_FieldPropertyAssociation(context, (BasicPropertyAssociation) semanticObject);
                return;
            case Aadl2Package.BOOLEAN_LITERAL:
                sequence_BooleanLiteral(context, (BooleanLiteral) semanticObject);
                return;
            case Aadl2Package.BUS_ACCESS:
                sequence_BusAccess(context, (BusAccess) semanticObject);
                return;
            case Aadl2Package.BUS_IMPLEMENTATION:
                sequence_BusImplementation(context, (BusImplementation) semanticObject);
                return;
            case Aadl2Package.BUS_PROTOTYPE:
                sequence_BusPrototype(context, (BusPrototype) semanticObject);
                return;
            case Aadl2Package.BUS_SUBCOMPONENT:
                sequence_BusSubcomponent(context, (BusSubcomponent) semanticObject);
                return;
            case Aadl2Package.BUS_TYPE:
                sequence_BusType(context, (BusType) semanticObject);
                return;
            case Aadl2Package.CLASSIFIER_TYPE:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getClassifierTypeRule()) {
                    sequence_ClassifierType(context, (ClassifierType) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedClassifierTypeRule()) {
                    sequence_UnnamedClassifierType(context, (ClassifierType) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.CLASSIFIER_VALUE:
                if (rule == grammarAccess.getConstantPropertyExpressionRule() || rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getComponentClassifierTermRule()) {
                    sequence_ComponentClassifierTerm(context, (ClassifierValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getQCReferenceRule() || rule == grammarAccess.getPropertyOwnerRule()) {
                    sequence_QCReference(context, (ClassifierValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.COMPONENT_IMPLEMENTATION_REFERENCE:
                sequence_ComponentImplementationReference(context, (ComponentImplementationReference) semanticObject);
                return;
            case Aadl2Package.COMPONENT_PROTOTYPE_ACTUAL:
                sequence_ComponentReference(context, (ComponentPrototypeActual) semanticObject);
                return;
            case Aadl2Package.COMPONENT_PROTOTYPE_BINDING:
                sequence_ComponentPrototypeBinding(context, (ComponentPrototypeBinding) semanticObject);
                return;
            case Aadl2Package.COMPONENT_TYPE_RENAME:
                sequence_CTRename(context, (ComponentTypeRename) semanticObject);
                return;
            case Aadl2Package.COMPUTED_VALUE:
                sequence_ComputedTerm(context, (ComputedValue) semanticObject);
                return;
            case Aadl2Package.CONNECTED_ELEMENT:
                if (rule == grammarAccess.getConnectedElementChainRule()) {
                    sequence_ConnectedElementChain(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getConnectedElementRule()) {
                    sequence_ConnectedElement(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getAbstractConnectionEndRule()) {
                    sequence_ConnectedElement_InternalEvent_ProcessorPort(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getNestedConnectedElementRule()) {
                    sequence_ConnectedElement_NestedConnectedElement(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getProcessorConnectionEndRule()) {
                    sequence_ConnectedElement_ProcessorPort(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getAccessConnectionEndRule()) {
                    sequence_ConnectedElement_ProcessorSubprogram(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getInternalEventRule()) {
                    sequence_InternalEvent(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getProcessorPortRule()) {
                    sequence_ProcessorPort(context, (ConnectedElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getProcessorSubprogramRule()) {
                    sequence_ProcessorSubprogram(context, (ConnectedElement) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.CONTAINED_NAMED_ELEMENT:
                sequence_ContainmentPath(context, (ContainedNamedElement) semanticObject);
                return;
            case Aadl2Package.CONTAINMENT_PATH_ELEMENT:
                sequence_ContainmentPathElement(context, (ContainmentPathElement) semanticObject);
                return;
            case Aadl2Package.DATA_ACCESS:
                sequence_DataAccess(context, (DataAccess) semanticObject);
                return;
            case Aadl2Package.DATA_IMPLEMENTATION:
                sequence_DataImplementation(context, (DataImplementation) semanticObject);
                return;
            case Aadl2Package.DATA_PORT:
                sequence_DataPort(context, (DataPort) semanticObject);
                return;
            case Aadl2Package.DATA_PROTOTYPE:
                sequence_DataPrototype(context, (DataPrototype) semanticObject);
                return;
            case Aadl2Package.DATA_SUBCOMPONENT:
                sequence_DataSubcomponent(context, (DataSubcomponent) semanticObject);
                return;
            case Aadl2Package.DATA_TYPE:
                sequence_DataType(context, (DataType) semanticObject);
                return;
            case Aadl2Package.DEFAULT_ANNEX_LIBRARY:
                sequence_DefaultAnnexLibrary(context, (DefaultAnnexLibrary) semanticObject);
                return;
            case Aadl2Package.DEFAULT_ANNEX_SUBCLAUSE:
                sequence_DefaultAnnexSubclause(context, (DefaultAnnexSubclause) semanticObject);
                return;
            case Aadl2Package.DEVICE_IMPLEMENTATION:
                sequence_DeviceImplementation(context, (DeviceImplementation) semanticObject);
                return;
            case Aadl2Package.DEVICE_PROTOTYPE:
                sequence_DevicePrototype(context, (DevicePrototype) semanticObject);
                return;
            case Aadl2Package.DEVICE_SUBCOMPONENT:
                sequence_DeviceSubcomponent(context, (DeviceSubcomponent) semanticObject);
                return;
            case Aadl2Package.DEVICE_TYPE:
                sequence_DeviceType(context, (DeviceType) semanticObject);
                return;
            case Aadl2Package.END_TO_END_FLOW:
                sequence_EndToEndFlow(context, (EndToEndFlow) semanticObject);
                return;
            case Aadl2Package.END_TO_END_FLOW_SEGMENT:
                if (rule == grammarAccess.getETEConnectionFlowRule()) {
                    sequence_ETEConnectionFlow(context, (EndToEndFlowSegment) semanticObject);
                    return;
                } else if (rule == grammarAccess.getETESubcomponentFlowRule()) {
                    sequence_ETESubcomponentFlow(context, (EndToEndFlowSegment) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.ENUMERATION_LITERAL:
                sequence_EnumerationLiteral(context, (EnumerationLiteral) semanticObject);
                return;
            case Aadl2Package.ENUMERATION_TYPE:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getEnumerationTypeRule()) {
                    sequence_EnumerationType(context, (EnumerationType) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedEnumerationTypeRule()) {
                    sequence_UnnamedEnumerationType(context, (EnumerationType) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.EVENT_DATA_PORT:
                sequence_EventDataPort(context, (EventDataPort) semanticObject);
                return;
            case Aadl2Package.EVENT_DATA_SOURCE:
                sequence_EventDataSource(context, (EventDataSource) semanticObject);
                return;
            case Aadl2Package.EVENT_PORT:
                sequence_EventPort(context, (EventPort) semanticObject);
                return;
            case Aadl2Package.EVENT_SOURCE:
                sequence_EventSource(context, (EventSource) semanticObject);
                return;
            case Aadl2Package.FEATURE_CONNECTION:
                sequence_FeatureConnection(context, (FeatureConnection) semanticObject);
                return;
            case Aadl2Package.FEATURE_GROUP:
                sequence_FeatureGroup(context, (FeatureGroup) semanticObject);
                return;
            case Aadl2Package.FEATURE_GROUP_CONNECTION:
                sequence_FeatureGroupConnection(context, (FeatureGroupConnection) semanticObject);
                return;
            case Aadl2Package.FEATURE_GROUP_PROTOTYPE:
                sequence_FeatureGroupPrototype(context, (FeatureGroupPrototype) semanticObject);
                return;
            case Aadl2Package.FEATURE_GROUP_PROTOTYPE_ACTUAL:
                sequence_FeatureGroupPrototypeActual(context, (FeatureGroupPrototypeActual) semanticObject);
                return;
            case Aadl2Package.FEATURE_GROUP_PROTOTYPE_BINDING:
                sequence_FeatureGroupPrototypeBinding(context, (FeatureGroupPrototypeBinding) semanticObject);
                return;
            case Aadl2Package.FEATURE_GROUP_TYPE:
                sequence_FeatureGroupType(context, (FeatureGroupType) semanticObject);
                return;
            case Aadl2Package.FEATURE_GROUP_TYPE_RENAME:
                sequence_FGTRename(context, (FeatureGroupTypeRename) semanticObject);
                return;
            case Aadl2Package.FEATURE_PROTOTYPE:
                sequence_FeaturePrototype(context, (FeaturePrototype) semanticObject);
                return;
            case Aadl2Package.FEATURE_PROTOTYPE_BINDING:
                sequence_FeaturePrototypeBinding(context, (FeaturePrototypeBinding) semanticObject);
                return;
            case Aadl2Package.FEATURE_PROTOTYPE_REFERENCE:
                sequence_FeaturePrototypeReference(context, (FeaturePrototypeReference) semanticObject);
                return;
            case Aadl2Package.FLOW_END:
                sequence_FlowEnd(context, (FlowEnd) semanticObject);
                return;
            case Aadl2Package.FLOW_IMPLEMENTATION:
                if (rule == grammarAccess.getFlowPathImplRule()) {
                    sequence_FlowPathImpl(context, (FlowImplementation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getFlowImplementationRule()) {
                    sequence_FlowPathImpl_FlowSinkImpl_FlowSourceImpl(context, (FlowImplementation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getFlowSinkImplRule()) {
                    sequence_FlowSinkImpl(context, (FlowImplementation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getFlowSourceImplRule()) {
                    sequence_FlowSourceImpl(context, (FlowImplementation) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.FLOW_SEGMENT:
                if (rule == grammarAccess.getConnectionFlowRule()) {
                    sequence_ConnectionFlow(context, (FlowSegment) semanticObject);
                    return;
                } else if (rule == grammarAccess.getSubcomponentFlowRule()) {
                    sequence_SubcomponentFlow(context, (FlowSegment) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.FLOW_SPECIFICATION:
                if (rule == grammarAccess.getFlowSpecificationRule()) {
                    sequence_FlowPathSpec_FlowSinkSpec_FlowSourceSpec_FlowSpecRefinement(context, (FlowSpecification) semanticObject);
                    return;
                } else if (rule == grammarAccess.getFlowPathSpecRule()) {
                    sequence_FlowPathSpec(context, (FlowSpecification) semanticObject);
                    return;
                } else if (rule == grammarAccess.getFlowSinkSpecRule()) {
                    sequence_FlowSinkSpec(context, (FlowSpecification) semanticObject);
                    return;
                } else if (rule == grammarAccess.getFlowSourceSpecRule()) {
                    sequence_FlowSourceSpec(context, (FlowSpecification) semanticObject);
                    return;
                } else if (rule == grammarAccess.getFlowSpecRefinementRule()) {
                    sequence_FlowSpecRefinement(context, (FlowSpecification) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.GROUP_EXTENSION:
                sequence_GroupExtension(context, (GroupExtension) semanticObject);
                return;
            case Aadl2Package.IMPLEMENTATION_EXTENSION:
                sequence_ImplementationExtension(context, (ImplementationExtension) semanticObject);
                return;
            case Aadl2Package.INTEGER_LITERAL:
                if (rule == grammarAccess.getNumberValueRule() || rule == grammarAccess.getIntegerLitRule()) {
                    sequence_IntegerLit(context, (IntegerLiteral) semanticObject);
                    return;
                } else if (rule == grammarAccess.getConstantPropertyExpressionRule() || rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getIntegerTermRule() || rule == grammarAccess.getNumAltRule()) {
                    sequence_IntegerTerm(context, (IntegerLiteral) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.LIST_TYPE:
                sequence_ListType(context, (ListType) semanticObject);
                return;
            case Aadl2Package.LIST_VALUE:
                sequence_ListTerm(context, (ListValue) semanticObject);
                return;
            case Aadl2Package.MEMORY_IMPLEMENTATION:
                sequence_MemoryImplementation(context, (MemoryImplementation) semanticObject);
                return;
            case Aadl2Package.MEMORY_PROTOTYPE:
                sequence_MemoryPrototype(context, (MemoryPrototype) semanticObject);
                return;
            case Aadl2Package.MEMORY_SUBCOMPONENT:
                sequence_MemorySubcomponent(context, (MemorySubcomponent) semanticObject);
                return;
            case Aadl2Package.MEMORY_TYPE:
                sequence_MemoryType(context, (MemoryType) semanticObject);
                return;
            case Aadl2Package.METACLASS_REFERENCE:
                if (rule == grammarAccess.getAllReferenceRule()) {
                    sequence_AllReference(context, (MetaclassReference) semanticObject);
                    return;
                } else if (rule == grammarAccess.getQMReferenceRule() || rule == grammarAccess.getPropertyOwnerRule()) {
                    sequence_QMReference(context, (MetaclassReference) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.MODAL_PROPERTY_VALUE:
                if (rule == grammarAccess.getModalPropertyValueRule()) {
                    sequence_ModalPropertyValue(context, (ModalPropertyValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getOptionalModalPropertyValueRule()) {
                    sequence_OptionalModalPropertyValue(context, (ModalPropertyValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyValueRule()) {
                    sequence_PropertyValue(context, (ModalPropertyValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.MODE:
                sequence_Mode(context, (Mode) semanticObject);
                return;
            case Aadl2Package.MODE_BINDING:
                sequence_ModeRef(context, (ModeBinding) semanticObject);
                return;
            case Aadl2Package.MODE_TRANSITION:
                sequence_ModeTransition(context, (ModeTransition) semanticObject);
                return;
            case Aadl2Package.MODE_TRANSITION_TRIGGER:
                sequence_Trigger(context, (ModeTransitionTrigger) semanticObject);
                return;
            case Aadl2Package.NAMED_VALUE:
                if (rule == grammarAccess.getConstantValueRule() || rule == grammarAccess.getNumAltRule()) {
                    sequence_ConstantValue(context, (NamedValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getConstantPropertyExpressionRule() || rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getLiteralorReferenceTermRule()) {
                    sequence_LiteralorReferenceTerm(context, (NamedValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.NUMERIC_RANGE:
                if (rule == grammarAccess.getIntegerRangeRule()) {
                    sequence_IntegerRange(context, (NumericRange) semanticObject);
                    return;
                } else if (rule == grammarAccess.getRealRangeRule()) {
                    sequence_RealRange(context, (NumericRange) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.OPERATION:
                sequence_SignedConstant(context, (Operation) semanticObject);
                return;
            case Aadl2Package.PACKAGE_RENAME:
                if (rule == grammarAccess.getPackageRenameRule()) {
                    sequence_PackageRename(context, (PackageRename) semanticObject);
                    return;
                } else if (rule == grammarAccess.getRenameAllRule()) {
                    sequence_RenameAll(context, (PackageRename) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.PARAMETER:
                sequence_Parameter(context, (org.osate.aadl2.Parameter) semanticObject);
                return;
            case Aadl2Package.PARAMETER_CONNECTION:
                sequence_ParameterConnection(context, (ParameterConnection) semanticObject);
                return;
            case Aadl2Package.PORT_CONNECTION:
                sequence_PortConnection(context, (PortConnection) semanticObject);
                return;
            case Aadl2Package.PORT_PROXY:
                sequence_PortProxy(context, (PortProxy) semanticObject);
                return;
            case Aadl2Package.PORT_SPECIFICATION:
                sequence_PortSpecification(context, (PortSpecification) semanticObject);
                return;
            case Aadl2Package.PRIVATE_PACKAGE_SECTION:
                sequence_PrivatePackageSection(context, (PrivatePackageSection) semanticObject);
                return;
            case Aadl2Package.PROCESS_IMPLEMENTATION:
                sequence_ProcessImplementation(context, (ProcessImplementation) semanticObject);
                return;
            case Aadl2Package.PROCESS_PROTOTYPE:
                sequence_ProcessPrototype(context, (ProcessPrototype) semanticObject);
                return;
            case Aadl2Package.PROCESS_SUBCOMPONENT:
                sequence_ProcessSubcomponent(context, (ProcessSubcomponent) semanticObject);
                return;
            case Aadl2Package.PROCESS_TYPE:
                sequence_ProcessType(context, (ProcessType) semanticObject);
                return;
            case Aadl2Package.PROCESSOR_IMPLEMENTATION:
                sequence_ProcessorImplementation(context, (ProcessorImplementation) semanticObject);
                return;
            case Aadl2Package.PROCESSOR_PROTOTYPE:
                sequence_ProcessorPrototype(context, (ProcessorPrototype) semanticObject);
                return;
            case Aadl2Package.PROCESSOR_SUBCOMPONENT:
                sequence_ProcessorSubcomponent(context, (ProcessorSubcomponent) semanticObject);
                return;
            case Aadl2Package.PROCESSOR_TYPE:
                sequence_ProcessorType(context, (ProcessorType) semanticObject);
                return;
            case Aadl2Package.PROPERTY:
                sequence_PropertyDefinition(context, (Property) semanticObject);
                return;
            case Aadl2Package.PROPERTY_ASSOCIATION:
                if (rule == grammarAccess.getBasicPropertyAssociationRule()) {
                    sequence_BasicPropertyAssociation(context, (PropertyAssociation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPModelRule() || rule == grammarAccess.getContainedPropertyAssociationRule()) {
                    sequence_ContainedPropertyAssociation(context, (PropertyAssociation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyAssociationRule()) {
                    sequence_PropertyAssociation(context, (PropertyAssociation) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.PROPERTY_CONSTANT:
                sequence_PropertyConstant(context, (PropertyConstant) semanticObject);
                return;
            case Aadl2Package.PROPERTY_SET:
                sequence_PropertySet(context, (PropertySet) semanticObject);
                return;
            case Aadl2Package.PUBLIC_PACKAGE_SECTION:
                sequence_PublicPackageSection(context, (PublicPackageSection) semanticObject);
                return;
            case Aadl2Package.RANGE_TYPE:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getRangeTypeRule()) {
                    sequence_RangeType(context, (RangeType) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedRangeTypeRule()) {
                    sequence_UnnamedRangeType(context, (RangeType) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.RANGE_VALUE:
                sequence_NumericRangeTerm(context, (RangeValue) semanticObject);
                return;
            case Aadl2Package.REAL_LITERAL:
                if (rule == grammarAccess.getNumberValueRule() || rule == grammarAccess.getRealLitRule()) {
                    sequence_RealLit(context, (RealLiteral) semanticObject);
                    return;
                } else if (rule == grammarAccess.getConstantPropertyExpressionRule() || rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getRealTermRule() || rule == grammarAccess.getNumAltRule()) {
                    sequence_RealTerm(context, (RealLiteral) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.REALIZATION:
                sequence_Realization(context, (Realization) semanticObject);
                return;
            case Aadl2Package.RECORD_TYPE:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getRecordTypeRule()) {
                    sequence_RecordType(context, (RecordType) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedRecordTypeRule()) {
                    sequence_UnnamedRecordType(context, (RecordType) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.RECORD_VALUE:
                if (rule == grammarAccess.getOldRecordTermRule()) {
                    sequence_OldRecordTerm(context, (RecordValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getConstantPropertyExpressionRule() || rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getRecordTermRule()) {
                    sequence_RecordTerm(context, (RecordValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.REFERENCE_TYPE:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getReferenceTypeRule()) {
                    sequence_ReferenceType(context, (ReferenceType) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedReferenceTypeRule()) {
                    sequence_UnnamedReferenceType(context, (ReferenceType) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.REFERENCE_VALUE:
                sequence_ReferenceTerm(context, (ReferenceValue) semanticObject);
                return;
            case Aadl2Package.STRING_LITERAL:
                sequence_StringTerm(context, (StringLiteral) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_ACCESS:
                sequence_SubprogramAccess(context, (SubprogramAccess) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_CALL:
                sequence_SubprogramCall(context, (SubprogramCall) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_CALL_SEQUENCE:
                sequence_SubprogramCallSequence(context, (SubprogramCallSequence) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_GROUP_ACCESS:
                sequence_SubprogramGroupAccess(context, (SubprogramGroupAccess) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_GROUP_IMPLEMENTATION:
                sequence_SubprogramGroupImplementation(context, (SubprogramGroupImplementation) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_GROUP_PROTOTYPE:
                sequence_SubprogramGroupPrototype(context, (SubprogramGroupPrototype) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_GROUP_SUBCOMPONENT:
                sequence_SubprogramGroupSubcomponent(context, (SubprogramGroupSubcomponent) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_GROUP_TYPE:
                sequence_SubprogramGroupType(context, (SubprogramGroupType) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_IMPLEMENTATION:
                sequence_SubprogramImplementation(context, (SubprogramImplementation) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_PROTOTYPE:
                sequence_SubprogramPrototype(context, (SubprogramPrototype) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_PROXY:
                sequence_SubprogramProxy(context, (SubprogramProxy) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_SUBCOMPONENT:
                sequence_SubprogramSubcomponent(context, (SubprogramSubcomponent) semanticObject);
                return;
            case Aadl2Package.SUBPROGRAM_TYPE:
                sequence_SubprogramType(context, (SubprogramType) semanticObject);
                return;
            case Aadl2Package.SYSTEM_IMPLEMENTATION:
                sequence_SystemImplementation(context, (SystemImplementation) semanticObject);
                return;
            case Aadl2Package.SYSTEM_PROTOTYPE:
                sequence_SystemPrototype(context, (SystemPrototype) semanticObject);
                return;
            case Aadl2Package.SYSTEM_SUBCOMPONENT:
                sequence_SystemSubcomponent(context, (SystemSubcomponent) semanticObject);
                return;
            case Aadl2Package.SYSTEM_TYPE:
                sequence_SystemType(context, (SystemType) semanticObject);
                return;
            case Aadl2Package.THREAD_GROUP_IMPLEMENTATION:
                sequence_ThreadGroupImplementation(context, (ThreadGroupImplementation) semanticObject);
                return;
            case Aadl2Package.THREAD_GROUP_PROTOTYPE:
                sequence_ThreadGroupPrototype(context, (ThreadGroupPrototype) semanticObject);
                return;
            case Aadl2Package.THREAD_GROUP_SUBCOMPONENT:
                sequence_ThreadGroupSubcomponent(context, (ThreadGroupSubcomponent) semanticObject);
                return;
            case Aadl2Package.THREAD_GROUP_TYPE:
                sequence_ThreadGroupType(context, (ThreadGroupType) semanticObject);
                return;
            case Aadl2Package.THREAD_IMPLEMENTATION:
                sequence_ThreadImplementation(context, (ThreadImplementation) semanticObject);
                return;
            case Aadl2Package.THREAD_PROTOTYPE:
                sequence_ThreadPrototype(context, (ThreadPrototype) semanticObject);
                return;
            case Aadl2Package.THREAD_SUBCOMPONENT:
                sequence_ThreadSubcomponent(context, (ThreadSubcomponent) semanticObject);
                return;
            case Aadl2Package.THREAD_TYPE:
                sequence_ThreadType(context, (ThreadType) semanticObject);
                return;
            case Aadl2Package.TYPE_EXTENSION:
                sequence_TypeExtension(context, (TypeExtension) semanticObject);
                return;
            case Aadl2Package.UNIT_LITERAL:
                if (rule == grammarAccess.getUnitLiteralConversionRule()) {
                    sequence_UnitLiteralConversion(context, (UnitLiteral) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnitLiteralRule()) {
                    sequence_UnitLiteral(context, (UnitLiteral) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.UNITS_TYPE:
                if (rule == grammarAccess.getPropertyTypeRule() || rule == grammarAccess.getUnitsTypeRule()) {
                    sequence_UnitsType(context, (UnitsType) semanticObject);
                    return;
                } else if (rule == grammarAccess.getUnnamedPropertyTypeRule() || rule == grammarAccess.getUnnamedUnitsTypeRule()) {
                    sequence_UnnamedUnitsType(context, (UnitsType) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.VIRTUAL_BUS_IMPLEMENTATION:
                sequence_VirtualBusImplementation(context, (VirtualBusImplementation) semanticObject);
                return;
            case Aadl2Package.VIRTUAL_BUS_PROTOTYPE:
                sequence_VirtualBusPrototype(context, (VirtualBusPrototype) semanticObject);
                return;
            case Aadl2Package.VIRTUAL_BUS_SUBCOMPONENT:
                sequence_VirtualBusSubcomponent(context, (VirtualBusSubcomponent) semanticObject);
                return;
            case Aadl2Package.VIRTUAL_BUS_TYPE:
                sequence_VirtualBusType(context, (VirtualBusType) semanticObject);
                return;
            case Aadl2Package.VIRTUAL_PROCESSOR_IMPLEMENTATION:
                sequence_VirtualProcessorImplementation(context, (VirtualProcessorImplementation) semanticObject);
                return;
            case Aadl2Package.VIRTUAL_PROCESSOR_PROTOTYPE:
                sequence_VirtualProcessorPrototype(context, (VirtualProcessorPrototype) semanticObject);
                return;
            case Aadl2Package.VIRTUAL_PROCESSOR_SUBCOMPONENT:
                sequence_VirtualProcessorSubcomponent(context, (VirtualProcessorSubcomponent) semanticObject);
                return;
            case Aadl2Package.VIRTUAL_PROCESSOR_TYPE:
                sequence_VirtualProcessorType(context, (VirtualProcessorType) semanticObject);
                return;
        }
    if (errorAcceptor != null)
        errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}