From 615b602f0a9b4ce9eca8c38b9aa780b81d03d8e7 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Wed, 6 Feb 2019 18:28:18 +0100 Subject: Extract component fault tree model --- .../serializer/CftLanguageSemanticSequencer.java | 172 ++++++++++++++------- 1 file changed, 120 insertions(+), 52 deletions(-) (limited to 'Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/serializer/CftLanguageSemanticSequencer.java') diff --git a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/serializer/CftLanguageSemanticSequencer.java b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/serializer/CftLanguageSemanticSequencer.java index 18682f69..835bb8cc 100644 --- a/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/serializer/CftLanguageSemanticSequencer.java +++ b/Stochastic/hu.bme.mit.inf.dslreasoner.faulttree.components/src-gen/hu/bme/mit/inf/dslreasoner/faulttree/components/serializer/CftLanguageSemanticSequencer.java @@ -4,22 +4,27 @@ package hu.bme.mit.inf.dslreasoner.faulttree.components.serializer; import com.google.inject.Inject; -import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.AndGate; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.Assignment; -import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.BasicEventDefinition; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.CftLanguagePackage; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.CftModel; -import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.ComponentDefinition; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.ComponentInstance; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.EventReference; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.ImportDeclaration; -import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.InputEvent; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.LookupDefinition; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.MappingDefinition; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.MappingParameter; -import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.OrGate; import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.TransformationDefinition; import hu.bme.mit.inf.dslreasoner.faulttree.components.services.CftLanguageGrammarAccess; +import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.AndGateDefinition; +import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.BasicEventDefinition; +import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.CftPackage; +import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.ComponentDefinition; +import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.IntputEvent; +import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.KOfMGateDefinition; +import hu.bme.mit.inf.dslreasoner.faulttree.model.cft.OrGateDefinition; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ConstantDistribution; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.ExponentialDistribution; +import hu.bme.mit.inf.dslreasoner.faulttree.model.ft.FtPackage; import java.util.Set; import org.eclipse.emf.ecore.EObject; import org.eclipse.emf.ecore.EPackage; @@ -43,23 +48,35 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ ParserRule rule = context.getParserRule(); Action action = context.getAssignedAction(); Set parameters = context.getEnabledBooleanParameters(); - if (epackage == CftLanguagePackage.eINSTANCE) + if (epackage == CftPackage.eINSTANCE) switch (semanticObject.eClass().getClassifierID()) { - case CftLanguagePackage.AND_GATE: - sequence_AndGate(context, (AndGate) semanticObject); + case CftPackage.AND_GATE_DEFINITION: + sequence_AndGateDefinition(context, (AndGateDefinition) semanticObject); return; + case CftPackage.BASIC_EVENT_DEFINITION: + sequence_BasicEventDefinition(context, (BasicEventDefinition) semanticObject); + return; + case CftPackage.COMPONENT_DEFINITION: + sequence_ComponentDefinition(context, (ComponentDefinition) semanticObject); + return; + case CftPackage.INTPUT_EVENT: + sequence_InputEvent(context, (IntputEvent) semanticObject); + return; + case CftPackage.KOF_MGATE_DEFINITION: + sequence_KOfMGateDefinition(context, (KOfMGateDefinition) semanticObject); + return; + case CftPackage.OR_GATE_DEFINITION: + sequence_OrGateDefinition(context, (OrGateDefinition) semanticObject); + return; + } + else if (epackage == CftLanguagePackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { case CftLanguagePackage.ASSIGNMENT: sequence_Assignment(context, (Assignment) semanticObject); return; - case CftLanguagePackage.BASIC_EVENT_DEFINITION: - sequence_BasicEventDefinition(context, (BasicEventDefinition) semanticObject); - return; case CftLanguagePackage.CFT_MODEL: sequence_CftModel(context, (CftModel) semanticObject); return; - case CftLanguagePackage.COMPONENT_DEFINITION: - sequence_ComponentDefinition(context, (ComponentDefinition) semanticObject); - return; case CftLanguagePackage.COMPONENT_INSTANCE: sequence_ComponentInstance(context, (ComponentInstance) semanticObject); return; @@ -69,9 +86,6 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ case CftLanguagePackage.IMPORT_DECLARATION: sequence_ImportDeclaration(context, (ImportDeclaration) semanticObject); return; - case CftLanguagePackage.INPUT_EVENT: - sequence_InputEvent(context, (InputEvent) semanticObject); - return; case CftLanguagePackage.LOOKUP_DEFINITION: sequence_LookupDefinition(context, (LookupDefinition) semanticObject); return; @@ -81,28 +95,33 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ case CftLanguagePackage.MAPPING_PARAMETER: sequence_MappingParameter(context, (MappingParameter) semanticObject); return; - case CftLanguagePackage.OR_GATE: - sequence_OrGate(context, (OrGate) semanticObject); - return; case CftLanguagePackage.TRANSFORMATION_DEFINITION: sequence_TransformationDefinition(context, (TransformationDefinition) semanticObject); return; } + else if (epackage == FtPackage.eINSTANCE) + switch (semanticObject.eClass().getClassifierID()) { + case FtPackage.CONSTANT_DISTRIBUTION: + sequence_ConstantDistribution(context, (ConstantDistribution) semanticObject); + return; + case FtPackage.EXPONENTIAL_DISTRIBUTION: + sequence_ExponentialDistribution(context, (ExponentialDistribution) semanticObject); + return; + } if (errorAcceptor != null) errorAcceptor.accept(diagnosticProvider.createInvalidContextOrTypeDiagnostic(semanticObject, context)); } /** * Contexts: - * EventDeclaration returns AndGate - * EventDefinition returns AndGate - * GateDefinition returns AndGate - * AndGate returns AndGate + * EventDefinition returns AndGateDefinition + * GateDefinition returns AndGateDefinition + * AndGateDefinition returns AndGateDefinition * * Constraint: - * (name=ID inputEvents+=[EventDeclaration|ID]*) + * (name=ValidId inputEvents+=[EventDeclaration|ValidId]*) */ - protected void sequence_AndGate(ISerializationContext context, AndGate semanticObject) { + protected void sequence_AndGateDefinition(ISerializationContext context, AndGateDefinition semanticObject) { genericSequencer.createSequence(context, semanticObject); } @@ -121,23 +140,22 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ /** * Contexts: - * EventDeclaration returns BasicEventDefinition * EventDefinition returns BasicEventDefinition * BasicEventDefinition returns BasicEventDefinition * * Constraint: - * (name=ID rate=DOULBE) + * (name=ValidId distribution=Distribution) */ protected void sequence_BasicEventDefinition(ISerializationContext context, BasicEventDefinition semanticObject) { if (errorAcceptor != null) { - if (transientValues.isValueTransient(semanticObject, CftLanguagePackage.Literals.EVENT_DECLARATION__NAME) == ValueTransient.YES) - errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CftLanguagePackage.Literals.EVENT_DECLARATION__NAME)); - if (transientValues.isValueTransient(semanticObject, CftLanguagePackage.Literals.BASIC_EVENT_DEFINITION__RATE) == ValueTransient.YES) - errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CftLanguagePackage.Literals.BASIC_EVENT_DEFINITION__RATE)); + if (transientValues.isValueTransient(semanticObject, CftPackage.Literals.EVENT_DECLARATION__NAME) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CftPackage.Literals.EVENT_DECLARATION__NAME)); + if (transientValues.isValueTransient(semanticObject, CftPackage.Literals.BASIC_EVENT_DEFINITION__DISTRIBUTION) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CftPackage.Literals.BASIC_EVENT_DEFINITION__DISTRIBUTION)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); - feeder.accept(grammarAccess.getBasicEventDefinitionAccess().getNameIDTerminalRuleCall_0_0(), semanticObject.getName()); - feeder.accept(grammarAccess.getBasicEventDefinitionAccess().getRateDOULBETerminalRuleCall_3_0(), semanticObject.getRate()); + feeder.accept(grammarAccess.getBasicEventDefinitionAccess().getNameValidIdParserRuleCall_0_0(), semanticObject.getName()); + feeder.accept(grammarAccess.getBasicEventDefinitionAccess().getDistributionDistributionParserRuleCall_1_0(), semanticObject.getDistribution()); feeder.finish(); } @@ -163,7 +181,7 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ * ComponentDefinition returns ComponentDefinition * * Constraint: - * (name=ID (inputEvents+=InputEvent | outputEvents+=[EventDeclaration|ID])* eventDefinitions+=EventDefinition*) + * (name=ValidId (inputEvents+=InputEvent | outputEvents+=[EventDeclaration|ValidId])* eventDefinitions+=EventDefinition*) */ protected void sequence_ComponentDefinition(ISerializationContext context, ComponentDefinition semanticObject) { genericSequencer.createSequence(context, semanticObject); @@ -183,12 +201,31 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ } + /** + * Contexts: + * Distribution returns ConstantDistribution + * ConstantDistribution returns ConstantDistribution + * + * Constraint: + * p=Double + */ + protected void sequence_ConstantDistribution(ISerializationContext context, ConstantDistribution semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, FtPackage.Literals.CONSTANT_DISTRIBUTION__P) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FtPackage.Literals.CONSTANT_DISTRIBUTION__P)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getConstantDistributionAccess().getPDoubleParserRuleCall_2_0(), semanticObject.getP()); + feeder.finish(); + } + + /** * Contexts: * EventReference returns EventReference * * Constraint: - * (component=[Variable|ID] event=[EventDeclaration|ID]) + * (component=[Variable|ValidId] event=[EventDeclaration|ValidId]) */ protected void sequence_EventReference(ISerializationContext context, EventReference semanticObject) { if (errorAcceptor != null) { @@ -198,8 +235,27 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CftLanguagePackage.Literals.EVENT_REFERENCE__EVENT)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); - feeder.accept(grammarAccess.getEventReferenceAccess().getComponentVariableIDTerminalRuleCall_0_0_1(), semanticObject.eGet(CftLanguagePackage.Literals.EVENT_REFERENCE__COMPONENT, false)); - feeder.accept(grammarAccess.getEventReferenceAccess().getEventEventDeclarationIDTerminalRuleCall_2_0_1(), semanticObject.eGet(CftLanguagePackage.Literals.EVENT_REFERENCE__EVENT, false)); + feeder.accept(grammarAccess.getEventReferenceAccess().getComponentVariableValidIdParserRuleCall_0_0_1(), semanticObject.eGet(CftLanguagePackage.Literals.EVENT_REFERENCE__COMPONENT, false)); + feeder.accept(grammarAccess.getEventReferenceAccess().getEventEventDeclarationValidIdParserRuleCall_2_0_1(), semanticObject.eGet(CftLanguagePackage.Literals.EVENT_REFERENCE__EVENT, false)); + feeder.finish(); + } + + + /** + * Contexts: + * Distribution returns ExponentialDistribution + * ExponentialDistribution returns ExponentialDistribution + * + * Constraint: + * lambda=Double + */ + protected void sequence_ExponentialDistribution(ISerializationContext context, ExponentialDistribution semanticObject) { + if (errorAcceptor != null) { + if (transientValues.isValueTransient(semanticObject, FtPackage.Literals.EXPONENTIAL_DISTRIBUTION__LAMBDA) == ValueTransient.YES) + errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, FtPackage.Literals.EXPONENTIAL_DISTRIBUTION__LAMBDA)); + } + SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); + feeder.accept(grammarAccess.getExponentialDistributionAccess().getLambdaDoubleParserRuleCall_2_0(), semanticObject.getLambda()); feeder.finish(); } @@ -224,13 +280,26 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ /** * Contexts: - * EventDeclaration returns InputEvent - * InputEvent returns InputEvent + * InputEvent returns IntputEvent + * + * Constraint: + * (name=ValidId multiple?='[]'?) + */ + protected void sequence_InputEvent(ISerializationContext context, IntputEvent semanticObject) { + genericSequencer.createSequence(context, semanticObject); + } + + + /** + * Contexts: + * EventDefinition returns KOfMGateDefinition + * GateDefinition returns KOfMGateDefinition + * KOfMGateDefinition returns KOfMGateDefinition * * Constraint: - * (name=ID multiple?='[]'?) + * (name=ValidId k=INT (m=INT | m=OF_INT) inputEvents+=[EventDeclaration|ValidId]*) */ - protected void sequence_InputEvent(ISerializationContext context, InputEvent semanticObject) { + protected void sequence_KOfMGateDefinition(ISerializationContext context, KOfMGateDefinition semanticObject) { genericSequencer.createSequence(context, semanticObject); } @@ -241,7 +310,7 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ * Variable returns LookupDefinition * * Constraint: - * (mapping=[MappingDefinition|ID] arguments+=[MappingParameter|ID] arguments+=[MappingParameter|ID]* name=ID) + * (mapping=[MappingDefinition|QualifiedName] arguments+=[MappingParameter|ValidId] arguments+=[MappingParameter|ValidId]* name=ValidId) */ protected void sequence_LookupDefinition(ISerializationContext context, LookupDefinition semanticObject) { genericSequencer.createSequence(context, semanticObject); @@ -272,7 +341,7 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ * MappingParameter returns MappingParameter * * Constraint: - * name=ID + * name=ValidId */ protected void sequence_MappingParameter(ISerializationContext context, MappingParameter semanticObject) { if (errorAcceptor != null) { @@ -280,22 +349,21 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ errorAcceptor.accept(diagnosticProvider.createFeatureValueMissing(semanticObject, CftLanguagePackage.Literals.MAPPING_PARAMETER__NAME)); } SequenceFeeder feeder = createSequencerFeeder(context, semanticObject); - feeder.accept(grammarAccess.getMappingParameterAccess().getNameIDTerminalRuleCall_0(), semanticObject.getName()); + feeder.accept(grammarAccess.getMappingParameterAccess().getNameValidIdParserRuleCall_0(), semanticObject.getName()); feeder.finish(); } /** * Contexts: - * EventDeclaration returns OrGate - * EventDefinition returns OrGate - * GateDefinition returns OrGate - * OrGate returns OrGate + * EventDefinition returns OrGateDefinition + * GateDefinition returns OrGateDefinition + * OrGateDefinition returns OrGateDefinition * * Constraint: - * (name=ID inputEvents+=[EventDeclaration|ID]*) + * (name=ValidId inputEvents+=[EventDeclaration|ValidId]*) */ - protected void sequence_OrGate(ISerializationContext context, OrGate semanticObject) { + protected void sequence_OrGateDefinition(ISerializationContext context, OrGateDefinition semanticObject) { genericSequencer.createSequence(context, semanticObject); } @@ -305,7 +373,7 @@ public class CftLanguageSemanticSequencer extends AbstractDelegatingSemanticSequ * TransformationDefinition returns TransformationDefinition * * Constraint: - * (name=ID mappingDefinitions+=MappingDefinition*) + * (name=ValidId mappingDefinitions+=MappingDefinition*) */ protected void sequence_TransformationDefinition(ISerializationContext context, TransformationDefinition semanticObject) { genericSequencer.createSequence(context, semanticObject); -- cgit v1.2.3-70-g09d2