use of com.helger.xsds.peppol.smp1.ProcessType 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());
}
}
}
use of com.helger.xsds.peppol.smp1.ProcessType in project VERDICT by ge-high-assurance.
the class Aadl2Vdm method translateProcessTypeObjects.
// End of translateAbstractTypeObjects
/**
* Analyzing each processType:
* 1. Determine if it is a lower-level system or higher-level system
* 2. If lower-level, add to componentType list attribute of Model
* 2.1 Populate the port, contract, cyberRel, safetyRel, event, id, compCategory
* fields of componentType of the Model object
* 3. If higher-level, assign to Model
* 3.1 Populate the safetyReq
* cyberReq, mission fields of Model object
* @param processTypes
* @param m1
* @return
*/
public Model translateProcessTypeObjects(List<ProcessType> processTypes, Model m1, HashSet<String> dataTypeDecl) {
for (ProcessType prcsType : processTypes) {
// variables for unpacking prcsType
List<Event> events = new ArrayList<>();
List<CyberMission> missionReqs = new ArrayList<>();
List<CyberRel> cyberRels = new ArrayList<>();
List<SafetyRel> safetyRels = new ArrayList<>();
List<CyberReq> cyberReqs = new ArrayList<>();
List<SafetyReq> safetyReqs = new ArrayList<>();
// a flag to check if a higher -level component has already been found
boolean higher_flag = false;
// unpacking prcsType
for (AnnexSubclause annex : prcsType.getOwnedAnnexSubclauses()) {
if (annex.getName().equalsIgnoreCase("verdict")) {
Verdict verdictAnnex = VerdictUtil.getVerdict(annex);
for (Statement statement : verdictAnnex.getElements()) {
if (statement instanceof Event) {
events.add((Event) statement);
} else if (statement instanceof CyberMission) {
missionReqs.add((CyberMission) statement);
} else if (statement instanceof CyberReq) {
cyberReqs.add((CyberReq) statement);
} else if (statement instanceof CyberRel) {
cyberRels.add((CyberRel) statement);
} else if (statement instanceof SafetyReq) {
safetyReqs.add((SafetyReq) statement);
} else if (statement instanceof SafetyRel) {
safetyRels.add((SafetyRel) statement);
}
}
}
}
/**
* For every ProcessType,
* populate the id, name, compCateg, port, event,
* cyberRel, and safetyRel fields of componentType
* and add it to the list of componentType
* of the Model object
*/
if (true) {
// No Filter-- do for all System Types
// to pack the memType as a VDM component
verdict.vdm.vdm_model.ComponentType packComponent = new verdict.vdm.vdm_model.ComponentType();
// Note: Not populating "contract" for now
// ISSUE: There is no getId() function for memoryType
packComponent.setId(prcsType.getQualifiedName());
// populating "name"
packComponent.setName(prcsType.getName());
// populating "compCateg"
packComponent.setCompCateg(prcsType.getCategory().getName());
// ISSUE: no getOwnedBusAccesses
// get all data accesses and store them as ports
List<DataAccess> dataAccesses = prcsType.getOwnedDataAccesses();
// checking each dataAccess's details and adding it to the port list
for (DataAccess dataAccess : dataAccesses) {
String portName = dataAccess.getName();
String modeString = "in";
if (dataAccess.getKind() == AccessType.PROVIDES) {
modeString = "providesDataAccess";
} else if (dataAccess.getKind() == AccessType.REQUIRES) {
modeString = "requiresDataAccess";
}
verdict.vdm.vdm_model.Port newPort = createVdmPort(portName, modeString, dataAccess.getQualifiedName());
// Note: Not populating "type" for now
// ISSUE: "probe", "event", and "id" not found in DataPort class or superclass
// add to port list of component
packComponent.getPort().add(newPort);
}
// End of checking each dataAccess
// get all ports
List<DataPort> dataPorts = prcsType.getOwnedDataPorts();
// checking each port's mode and name and adding it to the port list
for (DataPort dataPort : dataPorts) {
verdict.vdm.vdm_model.Port newPort = createVdmPort(dataPort, m1, dataTypeDecl);
// Note: Not populating "type" for now
// ISSUE: "probe", "event", and "id" not found in DataPort class or superclass
// add to port list of component
packComponent.getPort().add(newPort);
}
// End of checking each port
// get all event data ports
List<EventDataPort> eventDataPorts = prcsType.getOwnedEventDataPorts();
for (EventDataPort eventDataPort : eventDataPorts) {
verdict.vdm.vdm_model.Port newPort = createVdmPort(eventDataPort, m1, dataTypeDecl);
// add to port list of component
packComponent.getPort().add(newPort);
}
// get all event ports
List<EventPort> eventPorts = prcsType.getOwnedEventPorts();
for (EventPort eventPort : eventPorts) {
verdict.vdm.vdm_model.Port newPort = createVdmEventPort(eventPort);
// add to port list of component
packComponent.getPort().add(newPort);
}
// packing all events and adding to component
for (Event anEvent : events) {
// To pack the event as a VDM event
verdict.vdm.vdm_model.Event packEvent = createVdmEvent(anEvent);
// adding to the list of component's events
packComponent.getEvent().add(packEvent);
}
// packing all cyberRels and adding to component
for (CyberRel aCyberRel : cyberRels) {
// To pack the cyberRel as a VDM event
verdict.vdm.vdm_model.CyberRel packCyberRel = createVdmCyberRel(aCyberRel);
// adding to the list of component's Cyber relations
packComponent.getCyberRel().add(packCyberRel);
}
// packing all safetyRels and adding to component
for (SafetyRel aSafetyRel : safetyRels) {
// To pack the safetyRel as a VDM event
verdict.vdm.vdm_model.SafetyRel packSafetyRel = createVdmSafetyRel(aSafetyRel);
// adding to the list of component's Safety relations
packComponent.getSafetyRel().add(packSafetyRel);
}
// End of packing all safetyRels
// adding to the list of componenmemTypes of the Model object
m1.getComponentType().add(packComponent);
}
/**
* If a high-level system
* populate the name, safetyReq, cyberReq, and mission
* for the model object
*/
if (!cyberReqs.isEmpty() || !safetyReqs.isEmpty() || !missionReqs.isEmpty()) {
// checking if a high-level system has already been found
if (higher_flag == false) {
higher_flag = true;
} else {
System.out.println("Warning: Multiple high-level systems detected!");
}
// populating name
m1.setName(prcsType.getName());
// packing all safetyReqs and adding to model
for (SafetyReq aSafetyReq : safetyReqs) {
// To pack the safettReq as a VDM event
verdict.vdm.vdm_model.SafetyReq packSafetyReq = createVdmSafetyReq(aSafetyReq, prcsType.getFullName());
// adding to the list of model's Safety requirements
m1.getSafetyReq().add(packSafetyReq);
}
// packing all cyberReqs and adding to model
for (CyberReq aCyberReq : cyberReqs) {
// To pack the safettReq as a VDM event
verdict.vdm.vdm_model.CyberReq packCyberReq = createVdmCyberReq(aCyberReq, prcsType.getFullName());
// adding to the list of model's Cyber requirements
m1.getCyberReq().add(packCyberReq);
}
// packing all missionReqs and adding to model
for (CyberMission aMission : missionReqs) {
// To pack the safettReq as a VDM event
verdict.vdm.vdm_model.Mission packMission = createVdmMission(aMission);
// adding to the list of model's Mission
m1.getMission().add(packMission);
}
// End of packing all missionReqs
}
// End of if a higher-level system
}
// returning the populated Model
return m1;
}
use of com.helger.xsds.peppol.smp1.ProcessType 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;
}
use of com.helger.xsds.peppol.smp1.ProcessType 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;
}
use of com.helger.xsds.peppol.smp1.ProcessType 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));
}
Aggregations