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

Example 1 with ListType

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

the class AadlTypeWrapper method getListType.

/**
 * Creates a new instance of every invocation.
 */
@Override
public VerdictType getListType() {
    ListType listType = Aadl2Factory.eINSTANCE.createListType();
    listType.setOwnedElementType(type);
    return new AadlTypeWrapper("list of " + fullName, listType);
}

Example 2 with ListType

use of org.osate.aadl2.ListType 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 3 with ListType

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

the class PropertiesValidator method typeCheckPropertyValues.

/**
 * checks and report mismatch in type of value and type
 *
 * @param pt:
 *            PropertyType or unresolved proxy or null
 * @param pv:
 *            PropertyExpression or null
 * @param prefix:
 *            String prefix to error message used for lists
 * @since 2.0
 */
protected void typeCheckPropertyValues(PropertyType pt, PropertyExpression pv, String prefix, Element holder, String defName, int depth) {
    if (Aadl2Util.isNull(pt) || pv == null || holder == null) {
        return;
    }
    if (depth > 50) {
        error(holder, "Cyclic value discovered for '" + defName + "'");
        return;
    }
    depth++;
    String msg = " to property '" + defName + "' of type '" + pt.eClass().getName() + "'";
    if (!prefix.isEmpty() && !prefix.startsWith(" ")) {
        prefix = prefix + " ";
    }
    if (pv instanceof ListValue) {
        if (pt instanceof ListType) {
            typeMatchListElements(((ListType) pt).getElementType(), ((ListValue) pv).getOwnedListElements(), holder, defName, depth);
        } else {
            error(holder, prefix + "Assigning a list of values" + msg);
        }
    } else if (pv instanceof Operation || pv instanceof BooleanLiteral) {
        if (!(pt instanceof AadlBoolean)) {
            error(holder, prefix + "Assigning a Boolean value" + msg);
        }
    } else if (pv instanceof StringLiteral) {
        if (!(pt instanceof AadlString)) {
            error(prefix + "Assigning String value" + msg, holder, null, ValidationMessageAcceptor.INSIGNIFICANT_INDEX, Diagnostic.LINKING_DIAGNOSTIC);
        }
    } else if (pv instanceof EnumerationLiteral || (pv instanceof NamedValue && ((NamedValue) pv).getNamedValue() instanceof EnumerationLiteral)) {
        if (!(pt instanceof EnumerationType)) {
            error(holder, prefix + "Assigning Enumeration literal" + msg);
        }
    } else if (pv instanceof UnitLiteral || (pv instanceof NamedValue && ((NamedValue) pv).getNamedValue() instanceof UnitLiteral)) {
        if (!(pt instanceof UnitsType)) {
            error(holder, prefix + "Assigning Unit literal" + msg);
        }
    } else if (pv instanceof IntegerLiteral) {
        if (!(pt instanceof AadlInteger)) {
            error(holder, prefix + "Assigning Integer value" + msg);
        } else if (checkUnits((AadlInteger) pt, (IntegerLiteral) pv, holder)) {
            checkInRange((AadlInteger) pt, (IntegerLiteral) pv);
        }
    } else if (pv instanceof RealLiteral) {
        if (!(pt instanceof AadlReal)) {
            error(holder, prefix + "Assigning Real value" + msg);
        } else if (checkUnits((AadlReal) pt, (RealLiteral) pv, holder)) {
            checkInRange((AadlReal) pt, (RealLiteral) pv);
        }
    } else if (pv instanceof RangeValue) {
        if (!(pt instanceof RangeType)) {
            error(holder, prefix + "Assigning Range value" + msg);
        } else {
            typeCheckPropertyValues(((RangeType) pt).getNumberType(), ((RangeValue) pv).getMinimumValue(), holder, defName, depth);
            typeCheckPropertyValues(((RangeType) pt).getNumberType(), ((RangeValue) pv).getMaximumValue(), holder, defName, depth);
            typeCheckPropertyValues(((RangeType) pt).getNumberType(), ((RangeValue) pv).getDeltaValue(), holder, defName, depth);
        }
    } else if (pv instanceof ClassifierValue) {
        if (!(pt instanceof ClassifierType)) {
            error(holder, prefix + "Assigning incorrect Classifier value" + msg);
            return;
        }
        ClassifierValue cv = (ClassifierValue) pv;
        ClassifierType ct = (ClassifierType) pt;
        if (ct.getClassifierReferences().isEmpty()) {
            return;
        }
        for (MetaclassReference mcri : ct.getClassifierReferences()) {
            if (mcri.getMetaclass() != null && mcri.getMetaclass().isSuperTypeOf(cv.getClassifier().eClass())) {
                return;
            }
        }
        error(holder, prefix + "Assigning classifier value with incorrect Classifier" + msg);
    } else if (pv instanceof RecordValue) {
        if (!(pt instanceof RecordType)) {
            error(holder, prefix + "Assigning Record value" + msg);
        } else {
            typeMatchRecordFields(((RecordValue) pv).getOwnedFieldValues(), holder, defName, depth);
        }
    } else if (pv instanceof ReferenceValue) {
        if (!(pt instanceof ReferenceType)) {
            error(holder, prefix + "Assigning incorrect reference value" + msg);
        } else {
            ReferenceType ptrt = (ReferenceType) pt;
            if (ptrt.getNamedElementReferences().isEmpty()) {
                return;
            }
            ReferenceValue pvrv = (ReferenceValue) pv;
            EList<ContainmentPathElement> cpes = pvrv.getContainmentPathElements();
            if (!cpes.isEmpty()) {
                NamedElement ne = cpes.get(cpes.size() - 1).getNamedElement();
                for (MetaclassReference mcri : ptrt.getNamedElementReferences()) {
                    if (mcri.getMetaclass().isSuperTypeOf(ne.eClass())) {
                        return;
                    }
                }
                error(holder, prefix + "Assigning reference value with incorrect Named Element class" + msg);
            }
        }
    } else if (pv instanceof NamedValue) {
        AbstractNamedValue nv = ((NamedValue) pv).getNamedValue();
        if (nv instanceof PropertyConstant) {
            final PropertyConstant propertyConstant = (PropertyConstant) nv;
            final PropertyType pct = propertyConstant.getPropertyType();
            if (!Aadl2Util.isNull(pct) && !Aadl2Util.arePropertyTypesEqual(pt, pct)) {
                final String expected = getTypeName(pt);
                final String actual = getTypeName(pct);
                if (actual != null) {
                    if (expected != null) {
                        error(holder, "Property value of type " + actual + "; expected type " + expected);
                    } else {
                        error(holder, "Propery value of type " + actual + " does not match expected type");
                    }
                } else {
                    if (expected != null) {
                        error(holder, "Property value is not of expected type " + expected);
                    } else {
                        error(holder, "Propery value is not of expected type");
                    }
                }
            } else {
                // Issue 2222: is this still really necessary?
                typeCheckPropertyValues(pt, propertyConstant.getConstantValue(), holder, defName, depth);
            }
        } else if (nv instanceof Property) {
            PropertyType pvt = ((Property) nv).getPropertyType();
            if (!Aadl2Util.isNull(pvt)) {
                if (pvt.eClass() != pt.eClass() || !Aadl2Util.arePropertyTypesEqual(pt, pvt)) {
                    final String expected = getTypeName(pt);
                    final String actual = getTypeName(pvt);
                    if (actual != null) {
                        if (expected != null) {
                            error(holder, "Property value of type " + actual + "; expected type " + expected);
                        } else {
                            error(holder, "Propery value of type " + actual + " does not match expected type");
                        }
                    } else {
                        if (expected != null) {
                            error(holder, "Property value is not of expected type " + expected);
                        } else {
                            error(holder, "Propery value is not of expected type");
                        }
                    }
                }
            }
        } else {
            error(holder, "Enum/Unit literal validation should have happened before");
        }
    }
}

Example 4 with ListType

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

the class AadlBaNameResolver method propertyNameResolver.

private boolean propertyNameResolver(EList<DeclarativePropertyName> propertyNames) {
    // Ambiguity between a property literal and a property name without field.
    // So the next property name is evaluated.
    // The first property name has already been resolved, excepted its field.
    ListIterator<DeclarativePropertyName> it = propertyNames.listIterator();
    DeclarativePropertyName currentName = it.next();
    Element previousContainer = null;
    int previousContainerId = -1;
    // Then resolve the property field.
    if (false == propertyIndexAndFieldResolution(currentName)) {
        return false;
    }
    while (it.hasNext()) {
        previousContainer = currentName.getOsateRef();
        previousContainerId = previousContainer.eClass().getClassifierID();
        currentName = it.next();
        // Case of properties defined by a property association.
        if (Aadl2Package.PROPERTY_ASSOCIATION == previousContainerId) {
            PropertyAssociation pa = (PropertyAssociation) previousContainer;
            if (propertyAssociationResolver(pa, currentName) && propertyIndexAndFieldResolution(currentName)) {
                continue;
            } else // Property association may exist but doesn't define the
            // property that interests us. So search within the property
            // definition.
            {
                previousContainer = pa.getProperty();
            }
        }
        // The sub property is defined within a property expression.
        if (previousContainer instanceof PropertyExpression) {
            if (propertyValueResolver((PropertyExpression) previousContainer, currentName) && propertyIndexAndFieldResolution(currentName)) {
                continue;
            } else // Try with the property expression type definition.
            {
                previousContainer = PropertyUtils.getContainingProperty((PropertyExpression) previousContainer);
            }
        }
        previousContainerId = previousContainer.eClass().getClassifierID();
        // Try to resolve the property name within the property declaration.
        if (Aadl2Package.PROPERTY == previousContainerId) {
            Property p = (Property) previousContainer;
            if (propertyDeclarationResolver(p, currentName) && propertyIndexAndFieldResolution(currentName)) {
                continue;
            } else // Then the property type definition.
            if (propertyTypeResolver(p.getPropertyType(), currentName) && propertyIndexAndFieldResolution(currentName)) {
                continue;
            } else {
                // propertyTypeResolver and propertyFieldResolution report any error.
                return false;
            }
        } else // BasciProperty EMF identifier == Aadl2Package.LIST_VALUE, why ????
        if (// Use instanceof instead.
        previousContainer instanceof BasicProperty) {
            // The sub property is defined within a Record field (basic property).
            BasicProperty bp = (BasicProperty) previousContainer;
            if (propertyTypeResolver(bp.getPropertyType(), currentName) && propertyIndexAndFieldResolution(currentName)) {
                continue;
            } else {
                // propertyTypeResolver and propertyFieldResolution report any error.
                return false;
            }
        } else // The property is defined within the type of a record.
        if (Aadl2Package.RECORD_TYPE == previousContainerId) {
            RecordType rt = (RecordType) previousContainer;
            if (recordFieldResolver(rt, currentName) && propertyIndexAndFieldResolution(currentName)) {
                continue;
            } else {
                return false;
            }
        } else if (Aadl2Package.ENUMERATION_TYPE == previousContainerId) {
            EnumerationType type = (EnumerationType) previousContainer;
            return enumerationTypeResolver(type, currentName);
        } else // other types like ListType, etc.
        {
            // As it doesn't make any sense to look after a name in a property type
            // report an error.
            reportNameError(currentName.getPropertyName(), currentName.getPropertyName().getId());
            return false;
        }
    }
    return true;
}

Example 5 with ListType

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

the class AadlBaNameResolver method propertyFieldIndexResolver.

private boolean propertyFieldIndexResolver(Element el, IntegerValue field, BasicProperty bProperty, int fieldIndex, DeclarativePropertyName declProName) {
    if (integerValueResolver(field)) {
        // Link to the default value, if it exists.
        if (Aadl2Package.LIST_VALUE == el.eClass().getClassifierID() && propertyFieldListValueResolver(field, (ListValue) el, fieldIndex, declProName)) {
            return true;
        } else if (Aadl2Package.PROPERTY_ASSOCIATION == el.eClass().getClassifierID()) {
            PropertyAssociation pa = (PropertyAssociation) el;
            ModalPropertyValue mpv = pa.getOwnedValues().get(pa.getOwnedValues().size() - 1);
            PropertyExpression pe = mpv.getOwnedValue();
            if (Aadl2Package.LIST_VALUE == pe.eClass().getClassifierID()) {
                return propertyFieldListValueResolver(field, (ListValue) pe, fieldIndex, declProName);
            }
        }
        // the else statements: link with the property type.
        ListType lt = (ListType) bProperty.getPropertyType();
        declProName.setOsateRef(lt.getElementType());
        return true;
    } else {
        return false;
    }
}