Examples with TypeTransformationSet org.osate.xtext.aadl2.errormodel.errorModel.TypeTransformationSet used on opensource projects

Example 1 with TypeTransformationSet

use of org.osate.xtext.aadl2.errormodel.errorModel.TypeTransformationSet in project osate2 by osate.

the class ErrorModelSubclauseImpl method setTypeTransformationSet.

/**
 * <!-- begin-user-doc -->
 * <!-- end-user-doc -->
 * @generated
 */
@Override
public void setTypeTransformationSet(TypeTransformationSet newTypeTransformationSet) {
    TypeTransformationSet oldTypeTransformationSet = typeTransformationSet;
    typeTransformationSet = newTypeTransformationSet;
    if (eNotificationRequired())
        eNotify(new ENotificationImpl(this, Notification.SET, ErrorModelPackage.ERROR_MODEL_SUBCLAUSE__TYPE_TRANSFORMATION_SET, oldTypeTransformationSet, typeTransformationSet));
}

Example 2 with TypeTransformationSet

use of org.osate.xtext.aadl2.errormodel.errorModel.TypeTransformationSet in project osate2 by osate.

the class EMV2TypeSetUtil method reverseMapTypeTokenToContributor.

public static TypeSet reverseMapTypeTokenToContributor(TypeToken targettoken, TypeTransformationSet tts) {
    if (tts == null) {
        return null;
    }
    EList<TypeTransformation> ttlist = tts.getTransformation();
    for (TypeTransformation typeXform : ttlist) {
        TypeSet target = typeXform.getTarget();
        TypeSet contrib = typeXform.getContributor();
        if (contains(target, targettoken)) {
            return contrib;
        }
    }
    return null;
}

Example 3 with TypeTransformationSet

use of org.osate.xtext.aadl2.errormodel.errorModel.TypeTransformationSet in project osate2 by osate.

the class ErrorModelQualifiedNameProvider method getFullyQualifiedName.

// Enable to limit indexing to global items
// Duplicates checking only applies to global items
@Override
public QualifiedName getFullyQualifiedName(final EObject obj) {
    if (obj instanceof ErrorBehaviorStateMachine || obj instanceof TypeMappingSet || obj instanceof ErrorModelLibrary || obj instanceof ErrorModelSubclause || obj instanceof ErrorType || obj instanceof TypeSet || obj instanceof TypeTransformationSet) {
        /*
			 * It is important that we return null if obj is not in an
			 * AadlPackage or in a EMV2Root. This happens when serializing an
			 * aadl file with an error model annex. See EMV2AnnexUnparser. If
			 * this check is not here, then a ClassCastException occurs during
			 * serialization.
			 */
        NamedElement namedElement = (NamedElement) obj;
        NamedElement root = namedElement.getElementRoot();
        if (namedElement.getName() == null || !(root instanceof AadlPackage || root instanceof EMV2Root) || (obj instanceof ErrorModelSubclause && !(root instanceof EMV2Root))) {
            return null;
        }
        return getConverter().toQualifiedName(getTheName(namedElement));
    }
    if (obj instanceof AadlPackage) {
        return getConverter().toQualifiedName(((AadlPackage) obj).getName());
    }
    return null;
}

Example 4 with TypeTransformationSet

use of org.osate.xtext.aadl2.errormodel.errorModel.TypeTransformationSet in project osate2 by osate.

the class PropagationGraphBackwardTraversal method traverseIncomingErrorPropagation.

/**
 * traverse backwards according to propagation paths
 * if preProcessing result is non-null return it instead of result of actual traversal (used for shared subtrees)
 * handle external incoming propagations as origin by calling on processIncomingErrorPropagation
 * handle source outgoing propagation
 * collection of those results are post processed postProcessIncomingPropagation.
 * If empty incoming propagation itself is processed as "leaf" by processIncomingErrorPropagation
 * @param component component instance with incoming propagation
 * @param errorPropagation incoming propagation
 * @param type error type
 * @return EObject (can be null)
 */
private EObject traverseIncomingErrorPropagation(ComponentInstance component, ErrorPropagation errorPropagation, TypeToken proptype, BigDecimal scale) {
    List<EObject> results = new LinkedList<EObject>();
    Collection<TypeToken> filteredtypes = filterTokenThroughConstraint(errorPropagation.getTypeSet(), proptype);
    if (filteredtypes.isEmpty()) {
        return null;
    }
    boolean traversed = false;
    boolean hasCycle = false;
    List<EObject> subResults = new LinkedList<EObject>();
    for (TypeToken type : filteredtypes) {
        boolean didProp = false;
        // we want to track cycles.
        // we do that by tagging the feature instance of the error propagation with the error type (as token)
        ErrorModelState st = null;
        FeatureInstance fi = EMV2Util.findFeatureInstance(errorPropagation, component);
        if (fi != null) {
            st = (ErrorModelState) ErrorModelStateAdapterFactory.INSTANCE.adapt(fi, ErrorModelState.class);
        } else {
            st = (ErrorModelState) ErrorModelStateAdapterFactory.INSTANCE.adapt(component, ErrorModelState.class);
        }
        if (st.visited(errorPropagation, type)) {
            // we were there before.
            hasCycle = true;
            continue;
        } else {
            st.setVisitToken(errorPropagation, type);
        }
        EObject preResult = preProcessIncomingErrorPropagation(component, errorPropagation, type, scale);
        if (preResult != null) {
            // found common event
            addSubresult(results, preResult);
            continue;
        }
        for (PropagationGraphPath ppr : Util.getAllReversePropagationPaths(currentAnalysisModel, component, errorPropagation)) {
            // traverse incoming
            if (ppr.getConnection() != null) {
                ErrorSource ces = EMV2Util.findConnectionErrorSourceForConnection(ppr.getConnection());
                // the type constraint has to come from the error source as the connection does not have one
                if (ces != null && contains(ces.getTypeTokenConstraint(), type)) {
                    // XXX filter type
                    EObject result = processConnectionErrorSource(ppr.getConnection(), ces, type, scale);
                    addSubresult(subResults, result);
                    didProp = true;
                }
                ComponentInstance contextCI = ppr.getConnection().getComponentInstance();
                TypeTransformationSet tts = EMV2Util.getAllTypeTransformationSet(contextCI);
                for (PropagationPathEnd ppe : Util.getAllPropagationSourceEnds(currentAnalysisModel, ppr.getConnection())) {
                    ComponentInstance componentSource = ppe.getComponentInstance();
                    ErrorPropagation propagationSource = ppe.getErrorPropagation();
                    TypeSet newtype = reverseMapTypeTokenToContributor(type, tts);
                    if (newtype != null) {
                        EList<TypeToken> ttlist = flattenTypesetElements(newtype);
                        for (TypeToken typeToken : ttlist) {
                            TypeToken ntype = EMV2TypeSetUtil.contains(typeToken, type) ? type : typeToken;
                            EObject result = traverseOutgoingErrorPropagation(componentSource, propagationSource, ntype, scale);
                            addSubresult(subResults, result);
                            didProp = true;
                        }
                    } else {
                        EObject result = traverseOutgoingErrorPropagation(componentSource, propagationSource, type, scale);
                        addSubresult(subResults, result);
                        didProp = true;
                    }
                    // source of connection
                    newtype = reverseMapTypeTokenToSource(type, tts);
                    if (newtype != null) {
                        EList<TypeToken> ttlist = flattenTypesetElements(newtype);
                        for (TypeToken typeToken : ttlist) {
                            TypeToken ntype = EMV2TypeSetUtil.contains(typeToken, type) ? type : typeToken;
                            EObject result = traverseOutgoingErrorPropagation(componentSource, propagationSource, ntype, scale);
                            addSubresult(subResults, result);
                            didProp = true;
                        }
                    } else {
                        EObject result = traverseOutgoingErrorPropagation(componentSource, propagationSource, type, scale);
                        if (!addSubresult(subResults, result)) {
                            didProp = true;
                        }
                    }
                }
            }
            PropagationPathEnd ppe = ppr.getPathSrc();
            ComponentInstance componentSource = ppe.getComponentInstance();
            ErrorPropagation propagationSource = ppe.getErrorPropagation();
            if (propagationSource.getDirection() == DirectionType.IN) {
                // we have an external incoming propagation
                EObject result = processIncomingErrorPropagation(componentSource, propagationSource, type, scale);
                addSubresult(subResults, result);
                didProp = true;
            } else {
                EObject result = traverseOutgoingErrorPropagation(componentSource, propagationSource, type, scale);
                addSubresult(subResults, result);
                didProp = true;
            }
        }
        st.removeVisitedToken(errorPropagation, type);
        if (didProp) {
            traversed = true;
        }
    }
    if (!subResults.isEmpty()) {
        return postProcessIncomingErrorPropagation(component, errorPropagation, proptype, subResults, scale);
    }
    if (traversed || hasCycle) {
        return null;
    }
    // we have no subresults and did not prune. Allow handling of incoming propagation as endpoint of traversal
    return processIncomingErrorPropagation(component, errorPropagation, proptype, scale);
}

Example 5 with TypeTransformationSet

use of org.osate.xtext.aadl2.errormodel.errorModel.TypeTransformationSet in project osate2 by osate.

the class AbstractErrorModelSemanticSequencer 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.ARRAY_RANGE:
                sequence_ArrayRange(context, (ArrayRange) 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.CLASSIFIER_VALUE:
                sequence_ComponentClassifierTerm(context, (ClassifierValue) semanticObject);
                return;
            case Aadl2Package.COMPUTED_VALUE:
                sequence_ComputedTerm(context, (ComputedValue) semanticObject);
                return;
            case Aadl2Package.CONTAINED_NAMED_ELEMENT:
                sequence_ContainmentPath(context, (ContainedNamedElement) semanticObject);
                return;
            case Aadl2Package.CONTAINMENT_PATH_ELEMENT:
                sequence_ContainmentPathElement(context, (ContainmentPathElement) semanticObject);
                return;
            case Aadl2Package.INTEGER_LITERAL:
                sequence_IntegerTerm(context, (IntegerLiteral) semanticObject);
                return;
            case Aadl2Package.LIST_VALUE:
                sequence_ListTerm(context, (ListValue) semanticObject);
                return;
            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.NAMED_VALUE:
                if (rule == grammarAccess.getConstantValueRule() || rule == grammarAccess.getNumAltRule()) {
                    sequence_ConstantValue(context, (NamedValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getLiteralorReferenceTermRule()) {
                    sequence_LiteralorReferenceTerm(context, (NamedValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.OPERATION:
                sequence_SignedConstant(context, (Operation) 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.RANGE_VALUE:
                sequence_NumericRangeTerm(context, (RangeValue) semanticObject);
                return;
            case Aadl2Package.REAL_LITERAL:
                sequence_RealTerm(context, (RealLiteral) semanticObject);
                return;
            case Aadl2Package.RECORD_VALUE:
                if (rule == grammarAccess.getOldRecordTermRule()) {
                    sequence_OldRecordTerm(context, (RecordValue) semanticObject);
                    return;
                } else if (rule == grammarAccess.getPropertyExpressionRule() || rule == grammarAccess.getRecordTermRule()) {
                    sequence_RecordTerm(context, (RecordValue) semanticObject);
                    return;
                } else
                    break;
            case Aadl2Package.REFERENCE_VALUE:
                sequence_ReferenceTerm(context, (ReferenceValue) semanticObject);
                return;
            case Aadl2Package.STRING_LITERAL:
                sequence_StringTerm(context, (StringLiteral) semanticObject);
                return;
        }
    else if (epackage == ErrorModelPackage.eINSTANCE)
        switch(semanticObject.eClass().getClassifierID()) {
            case ErrorModelPackage.ALL_EXPRESSION:
                if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getConditionExpressionRule() || action == grammarAccess.getConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getAndExpressionRule() || action == grammarAccess.getAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getAllExpressionRule() || rule == grammarAccess.getConditionTermRule()) {
                    sequence_AllExpression(context, (AllExpression) semanticObject);
                    return;
                } else if (rule == grammarAccess.getSConditionExpressionRule() || action == grammarAccess.getSConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getSAndExpressionRule() || action == grammarAccess.getSAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getSAllExpressionRule() || rule == grammarAccess.getSConditionTermRule()) {
                    sequence_SAllExpression(context, (AllExpression) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.AND_EXPRESSION:
                if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getConditionExpressionRule() || action == grammarAccess.getConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getAndExpressionRule() || action == grammarAccess.getAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getConditionTermRule()) {
                    sequence_AndExpression(context, (AndExpression) semanticObject);
                    return;
                } else if (rule == grammarAccess.getSConditionExpressionRule() || action == grammarAccess.getSConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getSAndExpressionRule() || action == grammarAccess.getSAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getSConditionTermRule()) {
                    sequence_SAndExpression(context, (AndExpression) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.BRANCH_VALUE:
                sequence_BranchValue(context, (BranchValue) semanticObject);
                return;
            case ErrorModelPackage.COMPOSITE_STATE:
                sequence_CompositeState(context, (CompositeState) semanticObject);
                return;
            case ErrorModelPackage.CONDITION_ELEMENT:
                sequence_ConditionElement(context, (ConditionElement) semanticObject);
                return;
            case ErrorModelPackage.EMV2_PATH:
                if (rule == grammarAccess.getBasicEMV2PathRule()) {
                    sequence_BasicEMV2Path(context, (EMV2Path) semanticObject);
                    return;
                } else if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getEMV2PathRule()) {
                    sequence_EMV2Path(context, (EMV2Path) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.EMV2_PATH_ELEMENT:
                if (rule == grammarAccess.getEMV2ErrorPropagationPathRule()) {
                    sequence_EMV2ErrorPropagationPath(context, (EMV2PathElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getEMV2PathElementOrKindRule()) {
                    sequence_EMV2PathElementOrKind(context, (EMV2PathElement) semanticObject);
                    return;
                } else if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getEMV2PathElementRule()) {
                    sequence_EMV2PathElement(context, (EMV2PathElement) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.EMV2_PROPERTY_ASSOCIATION:
                if (rule == grammarAccess.getBasicEMV2PropertyAssociationRule()) {
                    sequence_BasicEMV2PropertyAssociation(context, (EMV2PropertyAssociation) semanticObject);
                    return;
                } else if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getEMV2PropertyAssociationRule()) {
                    sequence_EMV2PropertyAssociation(context, (EMV2PropertyAssociation) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.EMV2_ROOT:
                sequence_EMV2Root(context, (EMV2Root) semanticObject);
                return;
            case ErrorModelPackage.ERROR_BEHAVIOR_STATE:
                sequence_ErrorBehaviorState(context, (ErrorBehaviorState) semanticObject);
                return;
            case ErrorModelPackage.ERROR_BEHAVIOR_STATE_MACHINE:
                sequence_ErrorBehaviorStateMachine(context, (ErrorBehaviorStateMachine) semanticObject);
                return;
            case ErrorModelPackage.ERROR_BEHAVIOR_TRANSITION:
                sequence_ErrorBehaviorTransition(context, (ErrorBehaviorTransition) semanticObject);
                return;
            case ErrorModelPackage.ERROR_CODE_VALUE:
                sequence_ErrorCodeValue(context, (ErrorCodeValue) semanticObject);
                return;
            case ErrorModelPackage.ERROR_DETECTION:
                sequence_ErrorDetection(context, (ErrorDetection) semanticObject);
                return;
            case ErrorModelPackage.ERROR_EVENT:
                sequence_ErrorEvent(context, (ErrorEvent) semanticObject);
                return;
            case ErrorModelPackage.ERROR_MODEL_LIBRARY:
                if (rule == grammarAccess.getEMV2LibraryRule()) {
                    sequence_EMV2Library(context, (ErrorModelLibrary) semanticObject);
                    return;
                } else if (rule == grammarAccess.getAnnexLibraryRule() || rule == grammarAccess.getNamedElementRule() || rule == grammarAccess.getErrorModelLibraryRule()) {
                    sequence_ErrorModelLibrary(context, (ErrorModelLibrary) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.ERROR_MODEL_SUBCLAUSE:
                if (rule == grammarAccess.getEMV2SubclauseRule()) {
                    sequence_EMV2Subclause(context, (ErrorModelSubclause) semanticObject);
                    return;
                } else if (rule == grammarAccess.getAnnexSubclauseRule() || rule == grammarAccess.getModalElementRule() || rule == grammarAccess.getErrorModelSubclauseRule()) {
                    sequence_ErrorModelSubclause(context, (ErrorModelSubclause) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.ERROR_PATH:
                sequence_ErrorPath(context, (ErrorPath) semanticObject);
                return;
            case ErrorModelPackage.ERROR_PROPAGATION:
                sequence_ErrorPropagation(context, (ErrorPropagation) semanticObject);
                return;
            case ErrorModelPackage.ERROR_SINK:
                sequence_ErrorSink(context, (ErrorSink) semanticObject);
                return;
            case ErrorModelPackage.ERROR_SOURCE:
                sequence_ErrorSource(context, (ErrorSource) semanticObject);
                return;
            case ErrorModelPackage.ERROR_STATE_TO_MODE_MAPPING:
                sequence_ErrorStateToModeMapping(context, (ErrorStateToModeMapping) semanticObject);
                return;
            case ErrorModelPackage.ERROR_TYPE:
                sequence_TypeDefinition(context, (ErrorType) semanticObject);
                return;
            case ErrorModelPackage.FEATUREOR_PP_REFERENCE:
                sequence_FeatureorPPReference(context, (FeatureorPPReference) semanticObject);
                return;
            case ErrorModelPackage.IF_CONDITION:
                sequence_IfCondition(context, (IfCondition) semanticObject);
                return;
            case ErrorModelPackage.OR_EXPRESSION:
                if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getConditionExpressionRule() || action == grammarAccess.getConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getAndExpressionRule() || action == grammarAccess.getAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getConditionTermRule()) {
                    sequence_ConditionExpression(context, (OrExpression) semanticObject);
                    return;
                } else if (rule == grammarAccess.getSConditionExpressionRule() || action == grammarAccess.getSConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getSAndExpressionRule() || action == grammarAccess.getSAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getSConditionTermRule()) {
                    sequence_SConditionExpression(context, (OrExpression) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.ORLESS_EXPRESSION:
                if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getConditionExpressionRule() || action == grammarAccess.getConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getAndExpressionRule() || action == grammarAccess.getAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getOrlessExpressionRule() || rule == grammarAccess.getConditionTermRule()) {
                    sequence_OrlessExpression(context, (OrlessExpression) semanticObject);
                    return;
                } else if (rule == grammarAccess.getSConditionExpressionRule() || action == grammarAccess.getSConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getSAndExpressionRule() || action == grammarAccess.getSAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getSOrlessExpressionRule() || rule == grammarAccess.getSConditionTermRule()) {
                    sequence_SOrlessExpression(context, (OrlessExpression) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.ORMORE_EXPRESSION:
                if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getConditionExpressionRule() || action == grammarAccess.getConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getAndExpressionRule() || action == grammarAccess.getAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getOrmoreExpressionRule() || rule == grammarAccess.getConditionTermRule()) {
                    sequence_OrmoreExpression(context, (OrmoreExpression) semanticObject);
                    return;
                } else if (rule == grammarAccess.getSConditionExpressionRule() || action == grammarAccess.getSConditionExpressionAccess().getOrExpressionOperandsAction_1_0() || rule == grammarAccess.getSAndExpressionRule() || action == grammarAccess.getSAndExpressionAccess().getAndExpressionOperandsAction_1_0() || rule == grammarAccess.getSOrmoreExpressionRule() || rule == grammarAccess.getSConditionTermRule()) {
                    sequence_SOrmoreExpression(context, (OrmoreExpression) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.OUTGOING_PROPAGATION_CONDITION:
                sequence_OutgoingPropagationCondition(context, (OutgoingPropagationCondition) semanticObject);
                return;
            case ErrorModelPackage.PROPAGATION_PATH:
                sequence_PropagationPath(context, (PropagationPath) semanticObject);
                return;
            case ErrorModelPackage.PROPAGATION_POINT:
                sequence_PropagationPoint(context, (PropagationPoint) semanticObject);
                return;
            case ErrorModelPackage.QUALIFIED_ERROR_BEHAVIOR_STATE:
                sequence_QualifiedErrorBehaviorState(context, (QualifiedErrorBehaviorState) semanticObject);
                return;
            case ErrorModelPackage.QUALIFIED_ERROR_EVENT_OR_PROPAGATION:
                sequence_QualifiedErrorEventOrPropagation(context, (QualifiedErrorEventOrPropagation) semanticObject);
                return;
            case ErrorModelPackage.QUALIFIED_ERROR_PROPAGATION:
                sequence_QualifiedErrorPropagation(context, (QualifiedErrorPropagation) semanticObject);
                return;
            case ErrorModelPackage.QUALIFIED_PROPAGATION_POINT:
                sequence_QualifiedPropagationPoint(context, (QualifiedPropagationPoint) semanticObject);
                return;
            case ErrorModelPackage.RECOVER_EVENT:
                sequence_RecoverEvent(context, (RecoverEvent) semanticObject);
                return;
            case ErrorModelPackage.REPAIR_EVENT:
                sequence_RepairEvent(context, (RepairEvent) semanticObject);
                return;
            case ErrorModelPackage.REPORTING_PORT_REFERENCE:
                sequence_ReportingPortReference(context, (ReportingPortReference) semanticObject);
                return;
            case ErrorModelPackage.SCONDITION_ELEMENT:
                sequence_SConditionElement(context, (SConditionElement) semanticObject);
                return;
            case ErrorModelPackage.SUBCOMPONENT_ELEMENT:
                sequence_SubcomponentElement(context, (SubcomponentElement) semanticObject);
                return;
            case ErrorModelPackage.TRANSITION_BRANCH:
                sequence_TransitionBranch(context, (TransitionBranch) semanticObject);
                return;
            case ErrorModelPackage.TYPE_MAPPING:
                sequence_TypeMapping(context, (TypeMapping) semanticObject);
                return;
            case ErrorModelPackage.TYPE_MAPPING_SET:
                sequence_TypeMappingSet(context, (TypeMappingSet) semanticObject);
                return;
            case ErrorModelPackage.TYPE_SET:
                if (rule == grammarAccess.getNoErrorTypeSetRule()) {
                    sequence_NoErrorTypeSet(context, (TypeSet) semanticObject);
                    return;
                } else if (rule == grammarAccess.getTypeTokenOrNoErrorRule() || rule == grammarAccess.getTypeTokenConstraintNoErrorRule()) {
                    sequence_NoErrorTypeSet_TypeSetConstructor(context, (TypeSet) semanticObject);
                    return;
                } else if (rule == grammarAccess.getTypeSetConstructorRule() || rule == grammarAccess.getTypeSetReferenceRule() || rule == grammarAccess.getTypeTokenRule() || rule == grammarAccess.getTypeTokenConstraintRule()) {
                    sequence_TypeSetConstructor(context, (TypeSet) semanticObject);
                    return;
                } else if (rule == grammarAccess.getNamedElementRule() || rule == grammarAccess.getErrorTypesRule() || rule == grammarAccess.getTypeSetDefinitionRule()) {
                    sequence_TypeSetDefinition(context, (TypeSet) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.TYPE_TOKEN:
                if (rule == grammarAccess.getNoErrorTypeTokenRule()) {
                    sequence_NoErrorTypeToken(context, (TypeToken) semanticObject);
                    return;
                } else if (rule == grammarAccess.getElementRule() || rule == grammarAccess.getTypeSetElementRule()) {
                    sequence_TypeSetElement(context, (TypeToken) semanticObject);
                    return;
                } else
                    break;
            case ErrorModelPackage.TYPE_TRANSFORMATION:
                sequence_TypeTransformation(context, (TypeTransformation) semanticObject);
                return;
            case ErrorModelPackage.TYPE_TRANSFORMATION_SET:
                sequence_TypeTransformationSet(context, (TypeTransformationSet) semanticObject);
                return;
        }
    if (errorAcceptor != null)
        errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context));
}