use of org.osate.xtext.aadl2.errormodel.errorModel.OutgoingPropagationCondition in project osate2 by osate.
the class ErrorModelValidator method checkOutgoingConditionSourceTypes.
private void checkOutgoingConditionSourceTypes(OutgoingPropagationCondition opc) {
ErrorBehaviorState ebs = opc.getState();
if (ebs == null) {
return;
}
TypeSet ebsTS = ebs.getTypeSet();
TypeSet srcTS = opc.getTypeTokenConstraint();
if (srcTS == null) {
return;
}
if (ebsTS == null && srcTS != null) {
error(opc, "Error state " + ebs.getName() + " does not have a type set declared but the outgoing propagation condition has type token " + EMV2Util.getPrintName(srcTS));
} else if (!EMV2TypeSetUtil.contains(ebsTS, srcTS)) {
error(opc, "Outgoing condition state type set " + EMV2Util.getPrintName(srcTS) + " is not contained in type set of error behavior state \'" + ebs.getName() + "\'");
}
}
use of org.osate.xtext.aadl2.errormodel.errorModel.OutgoingPropagationCondition in project osate2 by osate.
the class PropagationGraphBackwardTraversal method traverseOutgoingErrorPropagation.
/**
* process an Outgoing Error Propagation by going backwards in the propagation graph
* if preProcessOutgoingerrorPropagation returns non-null return its value as traverse result.
* First we attempt to go backwards according to the component error behavior, i.e., the OutgoingPropagationCondition.
* If subresults is non-null then return value of postProcessingErrorPropagationCOndition.
* If not present we do it according to error flow specifications.
*
* @param component ComponentInstance
* @param errorPropagation outgoing ErrorPropagation
* @param type ErrorTypes
* @return EObject (can be null)
*/
public EObject traverseOutgoingErrorPropagation(final ComponentInstance component, final ErrorPropagation errorPropagation, TypeToken proptype, BigDecimal scale) {
List<EObject> subResults = new LinkedList<EObject>();
Collection<TypeToken> filteredTypes = filterTokenThroughConstraint(errorPropagation.getTypeSet(), proptype);
if (filteredTypes.isEmpty()) {
return null;
}
HashMultimap<ErrorPropagation, String> handledEOPs = HashMultimap.create();
boolean traverse = false;
boolean hasCycle = false;
for (TypeToken type : filteredTypes) {
// we did follow an OPC.
boolean didProp = false;
EObject found = preProcessOutgoingErrorPropagation(component, errorPropagation, type, scale);
if (found != null) {
addSubresult(subResults, found);
// found common event
continue;
}
// 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);
}
// processing call has to be after the preproccessing call so it is not found and we proceed in processing.
// On the other hand it needs to be called here so the event exists in ftamodel and is found the next time around.
// Originally we were creating the events bottom up thus the loop did not find the event.
// EObject myEvent = processOutgoingErrorPropagation(component, errorPropagation, type, scale);
Collection<ErrorFlow> errorFlows = EMV2Util.getAllErrorFlows(component);
Collection<OutgoingPropagationCondition> opcs = EMV2Util.getAllOutgoingPropagationConditions(component);
for (OutgoingPropagationCondition opc : opcs) {
if ((opc.getTypeToken() != null && !isNoError(opc.getTypeToken())) || opc.getTypeToken() == null) {
if (opc.isAllPropagations() || (EMV2Util.isSame(opc.getOutgoing(), errorPropagation))) {
// opc token if OPC token is subtype or same type
Collection<TypeToken> opcFilteredTypes = filterTokenThroughConstraint(opc.getTypeToken(), type);
for (TypeToken opctype : opcFilteredTypes) {
if (contains(opc.getTypeToken(), opctype)) {
EObject res = handleOutgoingErrorPropagationCondition(component, opc, opctype, handledEOPs, scale);
addSubresult(subResults, res);
didProp = true;
}
}
}
}
}
// try to find a path from an outer to an inner out error propagation
EList<PropagationPathEnd> propagationSources = Util.getAllPropagationSourceEnds(currentAnalysisModel, component, errorPropagation);
for (PropagationPathEnd ppe : propagationSources) {
ComponentInstance componentSource = ppe.getComponentInstance();
ErrorPropagation propagationSource = ppe.getErrorPropagation();
if (propagationSource.getDirection() == DirectionType.OUT) {
Set<ErrorPropagation> eops = handledEOPs.keySet();
if (!containsEOP(eops, propagationSource)) {
// if not already handled by a opc
EObject res = traverseOutgoingErrorPropagation(componentSource, propagationSource, type, scale);
addSubresult(subResults, res);
didProp = true;
}
}
}
for (ErrorFlow ef : errorFlows) {
if (ef instanceof ErrorPath) {
ErrorPath ep = (ErrorPath) ef;
if (handledEOPs.containsEntry(ep.getIncoming(), EMV2Util.getPrintName(type))) {
// already handled by a opc
continue;
}
if (Util.conditionHolds(ef, component)) {
/**
* Make sure that the error type we are looking for is contained
* in the error types for the out propagation.
* This is a fix for the JMR/SAVI WBS model.
*/
if (ep.isAllOutgoing() || EMV2Util.isSame(ep.getOutgoing(), errorPropagation)) {
BigDecimal newscale = scale;
double pathprobability = EMV2Properties.getProbability(component, ep, type);
if (pathprobability > 0) {
newscale = scale.multiply(BigDecimal.valueOf((pathprobability)));
}
if (ep.getTargetToken() != null) {
Collection<TypeToken> mappedTypes = filterTokenThroughConstraint(ep.getTargetToken(), type);
for (TypeToken mappedtype : mappedTypes) {
// we have a type mapping
EList<TypeToken> result;
if (ep.getTypeTokenConstraint() != null) {
// get type from path constraint
result = mapTokenThroughConstraint(ep.getTypeTokenConstraint(), mappedtype);
} else {
// get incoming type from propagation
result = mapTokenThroughConstraint(ep.getIncoming().getTypeSet(), mappedtype);
}
for (TypeToken newToken : result) {
if (ep.isAllIncoming()) {
Collection<ErrorPropagation> inprops = EMV2Util.getAllIncomingErrorPropagations(component);
for (ErrorPropagation eprop : inprops) {
handledEOPs.put(eprop, EMV2Util.getPrintName(newToken));
EObject newEvent = traverseIncomingErrorPropagation(component, eprop, newToken, newscale);
addSubresult(subResults, newEvent);
didProp = true;
}
} else {
handledEOPs.put(ep.getIncoming(), EMV2Util.getPrintName(newToken));
EObject newEvent = traverseIncomingErrorPropagation(component, ep.getIncoming(), newToken, newscale);
addSubresult(subResults, newEvent);
didProp = true;
}
}
}
} else {
// no type mapping
if (ep.isAllIncoming()) {
Collection<ErrorPropagation> inprops = EMV2Util.getAllIncomingErrorPropagations(component);
for (ErrorPropagation eprop : inprops) {
TypeSet matchtype = ep.getTypeTokenConstraint();
if (matchtype == null) {
matchtype = eprop.getTypeSet();
}
EList<TypeToken> filteredtypes = filterTokenThroughConstraint(matchtype, type);
for (TypeToken subtype : filteredtypes) {
handledEOPs.put(eprop, EMV2Util.getPrintName(subtype));
EObject newEvent = traverseIncomingErrorPropagation(component, eprop, subtype, newscale);
addSubresult(subResults, newEvent);
didProp = true;
}
}
} else {
ErrorPropagation inep = ep.getIncoming();
TypeSet matchtype = ep.getTypeTokenConstraint();
if (matchtype == null) {
matchtype = inep.getTypeSet();
}
Collection<TypeToken> mappedtypes = filterTokenThroughConstraint(matchtype, type);
for (TypeToken subtype : mappedtypes) {
handledEOPs.put(inep, EMV2Util.getPrintName(subtype));
EObject newEvent = traverseIncomingErrorPropagation(component, inep, subtype, newscale);
addSubresult(subResults, newEvent);
didProp = true;
}
}
}
}
}
} else if (ef instanceof ErrorSource) {
ErrorSource errorSource = (ErrorSource) ef;
NamedElement src = errorSource.getSourceModelElement();
if (src instanceof ErrorPropagation) {
// check if error source was already handled by opc
ErrorPropagation srcep = (ErrorPropagation) src;
if (targetsEOP(opcs, srcep, type)) {
// already handled by a opc with the same target
continue;
}
}
if (Util.conditionHolds(ef, component)) {
if (errorSource.isAll() || EMV2Util.isSame(errorSource.getSourceModelElement(), errorPropagation)) {
Collection<TypeToken> mappedTypes = filterTokenThroughConstraint(errorSource.getTypeTokenConstraint(), type);
for (TypeToken mappedType : mappedTypes) {
if (src instanceof ErrorPropagation) {
handledEOPs.put((ErrorPropagation) src, EMV2Util.getPrintName(mappedType));
}
if (errorSource.getFailureModeReference() != null) {
List<EObject> stResults = new LinkedList<EObject>();
ErrorBehaviorState ebs = errorSource.getFailureModeReference();
EObject sEvent = traverseErrorBehaviorState(component, ebs, mappedType, scale);
addSubresult(stResults, sEvent);
EObject newEvent = postProcessErrorSource(component, errorSource, proptype, stResults, scale);
addSubresult(subResults, newEvent);
didProp = true;
} else {
EObject newEvent = processErrorSource(component, errorSource, mappedType, scale);
addSubresult(subResults, newEvent);
didProp = true;
}
}
}
}
}
}
st.removeVisitedToken(errorPropagation, type);
if (didProp) {
traverse = true;
}
}
if (!subResults.isEmpty()) {
// out propagation with sub elements
return postProcessOutgoingErrorPropagation(component, errorPropagation, proptype, subResults, scale);
}
if (hasCycle) {
return null;
}
if (traverse && !handledEOPs.isEmpty()) {
// we handled error out propagations
return null;
}
// out propagation as end point
return processOutgoingErrorPropagation(component, errorPropagation, proptype, scale);
}
use of org.osate.xtext.aadl2.errormodel.errorModel.OutgoingPropagationCondition in project osate2 by osate.
the class PropagationGraphBackwardTraversal method handleOutgoingErrorPropagationCondition.
/**
* Process all OutgoingPropagationConditions that match the propagation and type of interest
* It is an OR of the OutgoingPropagationConditions that match.
* Fore each it is an AND of the source state (if it involves an error event or propagation).
* @param component ComponentInstance
* @param propagation (outgoing) ErrorPropagation
* @param type TypeToken
* @return Event (can be null)
*/
private EObject handleOutgoingErrorPropagationCondition(ComponentInstance component, OutgoingPropagationCondition opc, TypeToken type, HashMultimap<ErrorPropagation, String> handledEOPs, BigDecimal scale) {
EObject conditionResult = null;
EObject stateResult = null;
if (opc.getCondition() != null) {
conditionResult = processCondition(component, opc.getCondition(), opc.getCondition() == null ? type : null, FaultTreeUtils.BigOne, false);
}
ErrorBehaviorState state = opc.getState();
if (state != null) {
// use constraint as we have mapping
TypeSet newtypeset = null;
if (opc.getTypeTokenConstraint() != null) {
newtypeset = opc.getTypeTokenConstraint();
} else if (state.getTypeSet() != null) {
newtypeset = state.getTypeSet();
}
List<EObject> subResults = new LinkedList<EObject>();
if (newtypeset != null) {
EList<TypeToken> types = flattenTypesetElements(newtypeset);
for (TypeToken typeToken : types) {
EObject res = traverseErrorBehaviorState(component, state, typeToken, scale);
if (res != null) {
addSubresult(subResults, res);
}
}
if (subResults.isEmpty()) {
stateResult = processErrorBehaviorState(component, state, type, scale);
} else if (subResults.size() == 1) {
stateResult = subResults.get(0);
} else {
stateResult = postProcessXor(component, state, type, BigOne, subResults);
}
} else {
stateResult = traverseErrorBehaviorState(component, state, null, scale);
}
}
if (conditionResult == null && stateResult != null) {
for (ErrorBehaviorTransition trans : EMV2Util.getAllErrorBehaviorTransitions(component)) {
if (state == trans.getTarget()) {
Collection<ConditionElement> conde = EMV2Util.getAllConditionElementsFromConditionExpression(trans.getCondition());
for (ConditionElement conditionElement : conde) {
EventOrPropagation eop = EMV2Util.getErrorEventOrPropagation(conditionElement);
if (eop instanceof ErrorPropagation) {
handledEOPs.put((ErrorPropagation) eop, EMV2Util.getPrintName(type));
}
}
}
}
} else {
// error paths
Collection<ConditionElement> conde = EMV2Util.getAllConditionElementsFromConditionExpression(opc.getCondition());
for (ConditionElement conditionElement : conde) {
EventOrPropagation eop = EMV2Util.getErrorEventOrPropagation(conditionElement);
if (eop instanceof ErrorPropagation) {
handledEOPs.put((ErrorPropagation) eop, EMV2Util.getPrintName(type));
}
}
}
return processOutgoingErrorPropagationCondition(component, opc, type, conditionResult, stateResult, scale);
}
use of org.osate.xtext.aadl2.errormodel.errorModel.OutgoingPropagationCondition in project osate2 by osate.
the class FaultTreeUtils method getEMV2ElementDescription.
public static String getEMV2ElementDescription(Event event) {
// JH looks like the code to do the boxes in FTA
EObject errorModelArtifact = event.getRelatedEMV2Object();
TypeToken type = (TypeToken) event.getRelatedErrorType();
String description;
description = "";
if (errorModelArtifact instanceof ErrorSource) {
ErrorSource errorSource = (ErrorSource) errorModelArtifact;
description = (type != null ? "{" + EMV2Util.getName(type) + "} from " : "") + "error source '" + EMV2Util.getName(errorSource) + "'";
}
if (errorModelArtifact instanceof ErrorEvent) {
ErrorEvent ee = (ErrorEvent) errorModelArtifact;
if (type != null) {
description += "{" + EMV2Util.getName(type) + "} from ";
}
description += "error event '" + EMV2Util.getName(ee) + "'";
}
if (errorModelArtifact instanceof ErrorBehaviorState) {
if (type != null) {
description += "{" + EMV2Util.getName(type) + "} from ";
}
description += "error state '" + ((ErrorBehaviorState) errorModelArtifact).getName() + "'";
}
if (errorModelArtifact instanceof ErrorPropagation) {
String boundaryLabel = "";
if (event.getType() == EventType.EXTERNAL) {
boundaryLabel = "external";
} else if (event.getType() == EventType.UNDEVELOPED) {
boundaryLabel = "undeveloped";
}
if (type != null) {
description = "{" + EMV2Util.getName(type) + "}";
if (!boundaryLabel.isEmpty()) {
description += " from " + boundaryLabel;
}
} else {
description = boundaryLabel;
}
}
if (errorModelArtifact instanceof ConditionExpression) {
// TODO
errorModelArtifact = EMV2Util.getConditionExpressionContext(errorModelArtifact);
String opcontext = "";
if (type instanceof TypeSet) {
opcontext = " on type set " + EMV2Util.getPrintName((TypeSet) type);
} else if (errorModelArtifact instanceof ErrorBehaviorTransition) {
String branch = ((ErrorBehaviorTransition) errorModelArtifact).getDestinationBranches().isEmpty() ? "" : "branch ";
opcontext = " in transition " + branch + EMV2Util.getName(errorModelArtifact);
} else if (errorModelArtifact instanceof OutgoingPropagationCondition) {
opcontext = " in outgoing propagation condition " + EMV2Util.getName(errorModelArtifact);
} else if (errorModelArtifact instanceof ErrorDetection) {
opcontext = " in error detection " + EMV2Util.getName(errorModelArtifact);
} else if (errorModelArtifact instanceof CompositeState) {
opcontext = " in composite state " + EMV2Util.getName(errorModelArtifact);
}
if (event.getSubEventLogic() == LogicOperation.KORMORE) {
description = "'" + event.getSubEventLogic() + "' with k =" + event.getK() + opcontext;
} else {
description = "'" + event.getSubEventLogic() + "'" + opcontext;
}
}
return description;
}
use of org.osate.xtext.aadl2.errormodel.errorModel.OutgoingPropagationCondition 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));
}
Aggregations