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

Example 1 with ModeBinding

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

Example 2 with ModeBinding

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

the class ConfigureInModesSection method addLocalMode.

private void addLocalMode(final Composite container, final Map.Entry<ModeFeature, ButtonState> entry, final Set<ModeFeature> derivedModesAvailable, final Map<ModeFeature, ModeFeature> localToDerivedModeMap, final Set<URI> urisOfElementsWhichRequireModes) {
    final ModeFeature mf = entry.getKey();
    final Button modeBtn = getWidgetFactory().createButton(container, mf.getName(), SWT.CHECK);
    // Create derived mode drop down
    final ComboViewer derivedModeFld;
    final Label mappedLabel;
    if (derivedModesAvailable == null) {
        derivedModeFld = null;
        mappedLabel = null;
    } else {
        mappedLabel = getWidgetFactory().createLabel(container, "->", SWT.CENTER);
        mappedLabel.setText("->");
        // Create mapped derived mode combo
        derivedModeFld = new ComboViewer(container, SWT.DROP_DOWN | SWT.READ_ONLY);
        derivedModeFld.setContentProvider(ArrayContentProvider.getInstance());
        derivedModeFld.setLabelProvider(new LabelProvider() {

            @Override
            public String getText(final Object element) {
                if (element instanceof ModeFeature) {
                    final ModeFeature modalFeature = (ModeFeature) element;
                    return modalFeature.getName();
                }
                return element.toString();
            }
        });
        derivedModeFld.add("        ");
        derivedModeFld.add(derivedModesAvailable.toArray());
        final ModeFeature mappedDerivedMode = localToDerivedModeMap.get(mf);
        // If child mode is contained in intersection of derived modes
        if (derivedModesAvailable.contains(mappedDerivedMode)) {
            derivedModeFld.setSelection(new StructuredSelection(mappedDerivedMode));
        }
    }
    // Set button state
    final ButtonState modeFeatureState = entry.getValue();
    if (modeFeatureState == ButtonState.SELECTED) {
        modeBtn.setSelection(true);
    } else if (modeFeatureState == ButtonState.PARTIAL) {
        modeBtn.setSelection(true);
        modeBtn.setGrayed(true);
    } else if (modeFeatureState == ButtonState.DISABLED_AND_PARTIAL || modeFeatureState == ButtonState.DISABLED) {
        modeBtn.setEnabled(false);
        boolean partialDisabled = modeFeatureState == ButtonState.DISABLED_AND_PARTIAL;
        modeBtn.setGrayed(partialDisabled);
        modeBtn.setSelection(partialDisabled);
        if (derivedModeFld != null) {
            derivedModeFld.getCombo().setEnabled(false);
            mappedLabel.setEnabled(false);
        }
    }
    final SelectionListener selectionListener = new SelectionAdapter() {

        @Override
        public void widgetSelected(final SelectionEvent e) {
            // No changes if combo selection changes without enabled button
            if (e.widget instanceof Combo && !modeBtn.getSelection()) {
                return;
            }
            // Modify selected modal elements
            final boolean modeBtnIsSelected = modeBtn.getSelection();
            selectedBos.modify("Set In Modes", boc -> boc.getBusinessObject(NamedElement.class).isPresent(), boc -> {
                final NamedElement ne = boc.getBusinessObject(NamedElement.class).get();
                if (ne instanceof AnnexSubclause && ne.eContainer() instanceof DefaultAnnexSubclause) {
                    return (NamedElement) ne.eContainer();
                }
                return ne;
            }, (ne, boc) -> {
                final ModeFeature modeFeature = (ModeFeature) EcoreUtil.resolve(mf, ne.eResource());
                if (ne instanceof Subcomponent && modeFeature instanceof Mode) {
                    final Subcomponent sc = (Subcomponent) ne;
                    // Remove mode binding always
                    for (final ModeBinding mb : sc.getOwnedModeBindings()) {
                        if (modeFeature.getName().equalsIgnoreCase(mb.getParentMode().getName())) {
                            sc.getOwnedModeBindings().remove(mb);
                            break;
                        }
                    }
                    // Add mode binding on button selection
                    if (modeBtnIsSelected) {
                        final ModeBinding newModeBinding = sc.createOwnedModeBinding();
                        newModeBinding.setParentMode((Mode) modeFeature);
                        final boolean isDerived = urisOfElementsWhichRequireModes.contains(EcoreUtil.getURI(ne));
                        // If modal element is derived, set derived mode
                        if (isDerived) {
                            final Object selection = ((StructuredSelection) derivedModeFld.getSelection()).getFirstElement();
                            final ModeFeature childMode = selection instanceof ModeFeature ? (ModeFeature) selection : null;
                            newModeBinding.setDerivedMode((Mode) childMode);
                        }
                    }
                } else if (ne instanceof ModalPath) {
                    final ModalPath mp = (ModalPath) ne;
                    if (modeBtnIsSelected) {
                        mp.getInModeOrTransitions().add(modeFeature);
                    } else {
                        for (final ModeFeature mf : mp.getInModeOrTransitions()) {
                            if (modeFeature.getName().equalsIgnoreCase(mf.getName())) {
                                mp.getInModeOrTransitions().remove(mf);
                                break;
                            }
                        }
                    }
                } else if (ne instanceof ModalElement && modeFeature instanceof Mode) {
                    final ModalElement modalElement = (ModalElement) ne;
                    if (modeBtnIsSelected) {
                        modalElement.getAllInModes().add((Mode) modeFeature);
                    } else {
                        for (final ModeFeature mf : modalElement.getInModes()) {
                            if (modeFeature.getName().equalsIgnoreCase(mf.getName())) {
                                modalElement.getAllInModes().remove(modeFeature);
                                break;
                            }
                        }
                    }
                }
            });
        }
    };
    // Register selection listeners
    modeBtn.addSelectionListener(selectionListener);
    if (derivedModeFld != null) {
        derivedModeFld.getCombo().addSelectionListener(selectionListener);
    }
}

Example 3 with ModeBinding

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

the class ConfigureInModesSection method refresh.

@Override
public void refresh() {
    if (composite != null) {
        composite.dispose();
    }
    final Set<ModalElement> mes = selectedBos.boStream(ModalElement.class).collect(Collectors.toSet());
    // Selected Modal Elements and if element is derived
    final Set<URI> urisOfElementsWhichRequireModes = new HashSet<>();
    // Local modes and button state map
    Map<ModeFeature, ButtonState> localModes = null;
    // Mode transitions and button state map. Only used when a ModalPath is selected
    Map<ModeFeature, ButtonState> localModeTransitions = null;
    // In modes map for each selected modal element, child can be null
    final Map<ModeFeature, ModeFeature> localToDerivedModeMap = new TreeMap<ModeFeature, ModeFeature>(modeFeatureComparator);
    // Required mode features
    Set<ModeFeature> derivedModes = null;
    boolean nonModePathSelected = false;
    // Determine button states for mode features
    for (final ModalElement modalElement : mes) {
        if (modalElement.getContainingClassifier() instanceof ComponentClassifier) {
            final ComponentClassifier cc = (ComponentClassifier) modalElement.getContainingClassifier();
            // Use name for compatibility with flow implementations
            final Set<String> inModes = getInModes(modalElement);
            // Initial set
            if (localModes == null) {
                localModes = new TreeMap<ModeFeature, ButtonState>(modeFeatureComparator);
                for (final ModeFeature mf : cc.getAllModes()) {
                    localModes.put(mf, inModes.contains(mf.getName()) ? ButtonState.SELECTED : ButtonState.NOT_SELECTED);
                }
            } else {
                populateLocalModes(localModes, cc, inModes);
            }
            if (modalElement instanceof Subcomponent) {
                final URI scUri = EcoreUtil.getURI(modalElement);
                nonModePathSelected = true;
                final Subcomponent sc = (Subcomponent) modalElement;
                final ComponentClassifier scClassifier = sc.getAllClassifier();
                if (scClassifier != null) {
                    final List<Mode> scClassifierAllModes = scClassifier.getAllModes();
                    for (final Mode mb : scClassifierAllModes) {
                        if (mb.isDerived()) {
                            // Mark the modal element as derived
                            urisOfElementsWhichRequireModes.add(scUri);
                            if (derivedModes == null) {
                                derivedModes = new HashSet<>();
                                derivedModes.addAll(scClassifierAllModes);
                            } else {
                                // Keep intersection of owned modes between selections
                                derivedModes.retainAll(scClassifierAllModes);
                            }
                            break;
                        }
                    }
                }
                for (final ModeBinding modeBinding : sc.getOwnedModeBindings()) {
                    final ModeFeature localMode = modeBinding.getParentMode();
                    final ModeFeature derivedMode = modeBinding.getDerivedMode();
                    if (urisOfElementsWhichRequireModes.contains(scUri)) {
                        if (localToDerivedModeMap.containsKey(localMode)) {
                            if (localToDerivedModeMap.get(localMode) != derivedMode) {
                                localToDerivedModeMap.put(localMode, null);
                                localModes.replace(localMode, ButtonState.PARTIAL);
                            }
                        } else {
                            // Add mode if not already added and override derived value if not null
                            localToDerivedModeMap.put(localMode, derivedMode);
                        }
                    }
                }
            } else if (modalElement instanceof ModalPath) {
                final ModalPath modalPath = (ModalPath) modalElement;
                // Use name for compatibility with flow implementations
                final Set<String> inModeTransitions = getInModeTransitions(modalPath);
                // Set Initial
                if (localModeTransitions == null) {
                    localModeTransitions = new TreeMap<ModeFeature, ButtonState>(modeFeatureComparator);
                    for (final ModeFeature mf : cc.getAllModeTransitions()) {
                        localModeTransitions.put(mf, inModeTransitions.contains(mf.getName()) ? ButtonState.SELECTED : ButtonState.NOT_SELECTED);
                    }
                } else {
                    populateModeTransitions(localModeTransitions, cc, inModeTransitions);
                }
            } else {
                nonModePathSelected = true;
            }
        }
    }
    // Mode transitions are always partial if a modal path and any other type of modal element is selected
    if (localModeTransitions != null && nonModePathSelected) {
        for (final ModeFeature mf : localModeTransitions.keySet()) {
            if (localModeTransitions.get(mf) == ButtonState.SELECTED) {
                localModeTransitions.replace(mf, ButtonState.PARTIAL);
            }
        }
    }
    final int horizontalSpan = derivedModes == null ? 1 : 3;
    composite = getWidgetFactory().createComposite(container);
    FormData fd;
    fd = new FormData();
    fd.left = new FormAttachment(0, STANDARD_LABEL_WIDTH);
    composite.setLayoutData(fd);
    final GridLayout layout = new GridLayout(horizontalSpan, false);
    composite.setLayout(layout);
    // Determine if there is at least one mode feature is enabled. If no mode features are enabled then the selected elements do not have any
    // applicable mode features in common.
    final boolean hasEnabledModes = Stream.concat(localModes == null ? Stream.empty() : localModes.values().stream(), localModeTransitions == null ? Stream.empty() : localModeTransitions.values().stream()).anyMatch(ButtonState::isEnabled);
    final boolean hasModeSelections = Stream.concat(localModes == null ? Stream.empty() : localModes.values().stream(), localModeTransitions == null ? Stream.empty() : localModeTransitions.values().stream()).anyMatch(ButtonState::isAtleastPartiallySelected);
    final String inModesStatusTxt;
    if (!hasEnabledModes) {
        inModesStatusTxt = "<No Common Applicable Modes>";
    } else if (anyRefinedElementHasInheritedModeFeatures(mes)) {
        inModesStatusTxt = "<See Refined Element(s)>";
    } else if (hasModeSelections) {
        inModesStatusTxt = "Selected Modes";
    } else {
        inModesStatusTxt = "All";
    }
    final Label inModesStatus = getWidgetFactory().createLabel(composite, inModesStatusTxt);
    GridDataFactory.fillDefaults().span(horizontalSpan, 1).applyTo(inModesStatus);
    // Only show mode features if at least one mode feature is enabled.
    if (hasEnabledModes) {
        if (localModes != null && !localModes.isEmpty()) {
            GridDataFactory.fillDefaults().grab(true, false).span(horizontalSpan, 1).applyTo(new Label(composite, SWT.HORIZONTAL | SWT.SEPARATOR));
            for (final Map.Entry<ModeFeature, ButtonState> entry : localModes.entrySet()) {
                addLocalMode(composite, entry, derivedModes, localToDerivedModeMap, urisOfElementsWhichRequireModes);
            }
        }
        if (localModeTransitions != null && !localModeTransitions.isEmpty()) {
            GridDataFactory.fillDefaults().grab(true, false).span(horizontalSpan, 1).applyTo(new Label(composite, SWT.HORIZONTAL | SWT.SEPARATOR));
            for (final Map.Entry<ModeFeature, ButtonState> entry : localModeTransitions.entrySet()) {
                addLocalMode(composite, entry, derivedModes, localToDerivedModeMap, urisOfElementsWhichRequireModes);
            }
        }
    }
    container.layout(true);
    container.pack();
}

Example 4 with ModeBinding

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

the class SubcomponentImpl method createOwnedModeBinding.

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
public ModeBinding createOwnedModeBinding() {
    ModeBinding newOwnedModeBinding = (ModeBinding) create(Aadl2Package.eINSTANCE.getModeBinding());
    getOwnedModeBindings().add(newOwnedModeBinding);
    return newOwnedModeBinding;
}

Example 5 with ModeBinding

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

the class InstantiateModel method fillModes.

private void fillModes(ComponentInstance ci, List<Mode> modes) throws InterruptedException {
    for (Mode m : modes) {
        if (monitor.isCanceled()) {
            throw new InterruptedException();
        }
        ModeInstance mi = InstanceFactory.eINSTANCE.createModeInstance();
        /*
			 * Used to add the mode instance to the component instance at the end of the loop,
			 * but moved it here so that we can report errors on it.
			 */
        ci.getModeInstances().add(mi);
        mi.setMode(m);
        mi.setName(m.getName());
        mi.setInitial(m.isInitial());
        /*
			 * If ci is the root object, ignore derived. This means that we are instantiating an implementation that
			 * contains derived modes. In this case, treat the derived modes as normal modes since there is no
			 * containing component to provide a parent mode.
			 */
        if (m.isDerived() && !(ci instanceof SystemInstance)) {
            mi.setDerived(true);
            Subcomponent sub = ci.getSubcomponent();
            ComponentInstance parentci = ci.getContainingComponentInstance();
            final EList<ModeBinding> ownedModeBindings = sub.getOwnedModeBindings();
            if (ownedModeBindings == null || ownedModeBindings.isEmpty()) {
                // Implicit mode map, must find modes of the same name in the containing component
                ModeInstance foundParentMode = null;
                for (ModeInstance pmi : parentci.getModeInstances()) {
                    if (pmi.getName().equalsIgnoreCase(m.getName())) {
                        foundParentMode = pmi;
                        break;
                    }
                }
                if (foundParentMode == null) {
                    errManager.error(mi, "Required mode '" + m.getName() + "' not found in containing component");
                } else {
                    mi.getParents().add(foundParentMode);
                }
            } else {
                for (ModeBinding mb : ownedModeBindings) {
                    if (monitor.isCanceled()) {
                        throw new InterruptedException();
                    }
                    if (mb.getDerivedMode() == m || mb.getDerivedMode() == null && mb.getParentMode().getName().equalsIgnoreCase(m.getName())) {
                        mi.getParents().add(parentci.findModeInstance(mb.getParentMode()));
                    }
                }
            }
        }
    }
}