From 3f5aaab5025b8eb243f414b1c789085327df04f4 Mon Sep 17 00:00:00 2001 From: Kristóf Marussy Date: Wed, 20 Mar 2019 16:09:09 +0100 Subject: Fault tree transformation for partial models WIP --- .../application/ApplicationConfiguration.xtext | 26 ++- .../GenerateApplicationConfiguration.mwe2 | 1 + .../ApplicationConfigurationLinkingService.xtend | 186 ++++++++-------- .../ApplicationConfigurationScopeProvider.xtend | 233 +++++++++------------ 4 files changed, 215 insertions(+), 231 deletions(-) (limited to 'Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner') diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext index 6af31723..44ef8fd1 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/ApplicationConfiguration.xtext @@ -2,6 +2,7 @@ grammar hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration with org import "http://www.eclipse.org/emf/2002/Ecore" as ecore import "http://www.eclipse.org/viatra/query/patternlanguage/emf/PatternLanguage" as viatra +import "http://www.bme.hu/mit/inf/dslreasoner/faulttree/components/CftLanguage" as cftLanguage generate applicationConfiguration "http://www.bme.hu/mit/inf/dslreasoner/application/ApplicationConfiguration" ConfigurationScript: @@ -22,10 +23,11 @@ INTLiteral returns ecore::EInt: '-'? INT; // Imports /////////////////////////////////////////////////// -Import: EPackageImport | ViatraImport; +Import: EPackageImport | ViatraImport | CftImport; EPackageImport: "import" "epackage" importedPackage=[ecore::EPackage|STRING]; ViatraImport: "import" "viatra" importedViatra=[viatra::PatternModel|STRING]; +CftImport: "import" "reliability" importedCft=[cftLanguage::CftModel|STRING]; /////////////////////////////////////////////////// // Declaration @@ -38,6 +40,7 @@ Declaration : | GraphPatternDeclaration | ConfigDeclaration | ScopeDeclaration + | ObjectiveDeclaration ; /////////////////////////////////////////////////// @@ -88,6 +91,23 @@ GraphPatternDeclaration: 'constraints' name = ID specification = PatternSpecific GraphPatternReference: referred = [GraphPatternDeclaration]; GraphPattern: GraphPatternReference|PatternSpecification; +/////////////////////////////////////////////////// +// Objectives +/////////////////////////////////////////////////// + +ObjectiveSpecification: '{' entries += ObjectiveEntry (',' entries += ObjectiveEntry)* '}'; +ObjectiveEntry: OptimizationEntry | ThresholdEntry; +enum OptimizationDirection: MINIMIZE='minimize' | MAXIMIZE='maximize'; +OptimizationEntry: direction=OptimizationDirection function=ObjectiveFunction; +enum ComparisonOperator: LESS_EQUALS='<=' | GREATER_EQUALS='>='; +ThresholdEntry: function=ObjectiveFunction operator=ComparisonOperator threshold=REALLiteral; +ObjectiveFunction: ReliabiltiyFunction; +ReliabiltiyFunction: 'reliability' (package=[cftLanguage::CftModel|QualifiedName] '::')? transformation = [cftLanguage::TransformationDefinition]; + +ObjectiveDeclaration: 'objectives' name = ID specification = ObjectiveSpecification; +ObjectiveReference: referred = [ObjectiveDeclaration]; +Objective: ObjectiveReference|ObjectiveSpecification; + /////////////////////////////////////////////////// // SolverConfig /////////////////////////////////////////////////// @@ -99,7 +119,8 @@ ConfigDeclaration : 'config' name = ID specification = ConfigSpecification ; ConfigEntry: DocumentationEntry | RuntimeEntry | MemoryEntry | CustomEntry; -DocumentationEntry: "log-level" '=' level = DocumentLevelSpecification; enum DocumentLevelSpecification: none | normal | full; +DocumentationEntry: "log-level" '=' level = DocumentLevelSpecification; +enum DocumentLevelSpecification: none | normal | full; RuntimeEntry: "runtime" "=" millisecLimit = INT; MemoryEntry: "memory" "=" megabyteLimit = INT; CustomEntry: key = STRING "=" value = STRING; @@ -160,6 +181,7 @@ GenerationTask: 'generate' {GenerationTask} '{'( ('metamodel' '=' metamodel = Metamodel)? & ('partial-model' '=' partialModel = PartialModel)? & ('constraints' '=' patterns = GraphPattern)? & + ('objectives' '=' objectives = Objective)? & // model set ('scope' '=' scope = Scope)? & diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 index 13cc78a8..3983cd10 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/GenerateApplicationConfiguration.mwe2 @@ -31,6 +31,7 @@ Workflow { name = "hu.bme.mit.inf.dslreasoner.application.ApplicationConfiguration" referencedResource = "platform:/resource/org.eclipse.emf.ecore/model/Ecore.genmodel" referencedResource = "platform:/resource/org.eclipse.viatra.query.patternlanguage.emf/model/PatternLanguage.genmodel" + referencedResource = "platform:/resource/hu.bme.mit.inf.dslreasoner.faulttree.components/model/generated/CftLanguage.genmodel" fileExtensions = "vsconfig" serializer = { generateStub = false diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend index fc4b721a..ec79ac89 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/linking/ApplicationConfigurationLinkingService.xtend @@ -2,6 +2,7 @@ package hu.bme.mit.inf.dslreasoner.application.linking import com.google.inject.Inject import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.CftImport import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.EPackageImport import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternEntry @@ -11,8 +12,10 @@ import java.util.List import java.util.Optional import org.eclipse.emf.common.util.URI import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.EPackage import org.eclipse.emf.ecore.EReference import org.eclipse.emf.ecore.resource.Resource +import org.eclipse.emf.ecore.resource.ResourceSet import org.eclipse.viatra.query.patternlanguage.emf.scoping.IMetamodelProvider import org.eclipse.xtext.EcoreUtil2 import org.eclipse.xtext.conversion.IValueConverterService @@ -20,105 +23,98 @@ import org.eclipse.xtext.conversion.ValueConverterException import org.eclipse.xtext.linking.impl.DefaultLinkingService import org.eclipse.xtext.nodemodel.ILeafNode import org.eclipse.xtext.nodemodel.INode -import org.eclipse.emf.ecore.resource.ResourceSet -import org.eclipse.emf.ecore.EPackage -class ApplicationConfigurationLinkingService extends DefaultLinkingService{ +class ApplicationConfigurationLinkingService extends DefaultLinkingService { + @Inject IValueConverterService valueConverterService + @Inject IMetamodelProvider metamodelProvider - //@Inject Logger logger + public static extension ApplicationConfigurationPackage pac = ApplicationConfigurationPackage.eINSTANCE - @Inject IValueConverterService valueConverterService - @Inject IMetamodelProvider metamodelProvider - - public static extension ApplicationConfigurationPackage pac = ApplicationConfigurationPackage.eINSTANCE + override getLinkedObjects(EObject context, EReference ref, INode node) { + if (context instanceof EPackageImport) { + if (ref == EPackageImport_ImportedPackage && node instanceof ILeafNode) { + return getEPackage(context, node as ILeafNode) + } + } else if (context instanceof ViatraImport) { + if (ref == viatraImport_ImportedViatra) { + return getViatra(context, node) + } + } else if (context instanceof CftImport) { + if (ref == cftImport_ImportedCft) { + return getCftModel(context, node) + } + } + return super.getLinkedObjects(context, ref, node) + } + + private def getEPackage(EPackageImport packageImport, ILeafNode node) { + val x = getNSUri(node) + if (x.isPresent) { + val uriString = x.get + val epackageByMetamodelProvider = metamodelProvider.loadEPackage(uriString, + packageImport.eResource.resourceSet) + val epackageByMe = ePackageByMe(packageImport.eResource.resourceSet, uriString) + if (epackageByMetamodelProvider !== null) { + return Collections.singletonList(epackageByMetamodelProvider as EObject) + } else if (epackageByMe !== null) { + return Collections.singletonList(epackageByMe as EObject) + } else { + emptyList + } + } else { + return emptyList + } + } - override getLinkedObjects(EObject context, EReference ref, INode node) { - if(context instanceof EPackageImport) { - if(ref == EPackageImport_ImportedPackage && node instanceof ILeafNode) { - return getEPackage(context as EPackageImport, node as ILeafNode) - } - } else if(context instanceof ViatraImport) { - if(ref == viatraImport_ImportedViatra) { - return getViatra(context as ViatraImport, node) - } - } else if(context instanceof PatternEntry) { - if(ref === patternEntry_Package) { - return getViatraPackage(context as PatternEntry,node) - } - } - return super.getLinkedObjects(context, ref, node) - } + private def ePackageByMe(ResourceSet rs, String uri) { + try { + val resource = rs.getResource(URI.createURI(uri), true); + return resource.contents.head as EPackage + } catch (Exception e) { + return null + } + } + + private def getViatra(ViatraImport viatraImport, INode node) { + getByUri(viatraImport, viatraImport_ImportedViatra, node) + } - def getViatraPackage(PatternEntry entry, INode node) { - val document = EcoreUtil2.getContainerOfType(entry,ConfigurationScript) - val nodeString = valueConverterService.toValue(node.text, - linkingHelper.getRuleNameFrom(node.grammarElement), node).toString.replaceAll("\\s","") - val patternModels = document.imports.filter(ViatraImport).map[it.importedViatra].filterNull - val List patternModelsWithSameNamespace = patternModels.filter[nodeString.equals(it.packageName)].filter(EObject).toList - return patternModelsWithSameNamespace + private def getByUri(EObject context, EReference ref, INode node) { + val uri = getNSUri(node) + if (uri.present) { + var URI createdURI + try { + createdURI = URI.createURI(uri.get) + } catch (IllegalArgumentException e) { + return super.getLinkedObjects(context, ref, node) + } + var Resource res + try { + res = context.eResource.resourceSet.getResource(createdURI, true); + } catch (RuntimeException e) { + return super.getLinkedObjects(context, ref, node) + } + if (res !== null && res.contents !== null) { + return res.contents.filter[ref.EType.isInstance(it)].toList + } else { + return super.getLinkedObjects(context, ref, node) + } + } else { + return super.getLinkedObjects(context, ref, node) + } } - private def getEPackage(EPackageImport packageImport, ILeafNode node) { - val x = getNSUri(node) - if(x.isPresent) { - val uriString = x.get - val epackageByMetamodelProvider = metamodelProvider.loadEPackage(uriString, packageImport.eResource.resourceSet) - val epackageByMe = ePackageByMe(packageImport.eResource.resourceSet,uriString) - //println(epackageByMetamodelProvider) - //println(epackageByMe) - if(epackageByMetamodelProvider!==null) { - return Collections.singletonList(epackageByMetamodelProvider as EObject) - } else if(epackageByMe !== null) { - return Collections.singletonList(epackageByMe as EObject) - } else { - emptyList - } - } else { - return emptyList - } - } - - private def ePackageByMe(ResourceSet rs, String uri) { - try { - val resource = rs.getResource(URI.createURI(uri), true); - return resource.contents.head as EPackage - } catch (Exception e) { - return null - } - } - - private def getViatra(ViatraImport viatraImport, INode node) { - val uri = getNSUri(node) - if(uri.present) { - var URI createdURI - try{ - createdURI = URI.createURI(uri.get) - }catch(IllegalArgumentException e) { - return super.getLinkedObjects(viatraImport, viatraImport_ImportedViatra, node) - } - var Resource res - try{ - res = viatraImport.eResource.resourceSet.getResource(createdURI,true); - } catch(RuntimeException e){ - return super.getLinkedObjects(viatraImport, viatraImport_ImportedViatra, node) - } - if(res!==null && !res.contents.nullOrEmpty) { - return #[res.contents.head] - } else { - return super.getLinkedObjects(viatraImport, viatraImport_ImportedViatra, node) - } - } else { - return super.getLinkedObjects(viatraImport, viatraImport_ImportedViatra, node) - } - } - - private def getNSUri(INode node) { - try { - val convertedValue = valueConverterService.toValue(node.text, - linkingHelper.getRuleNameFrom(node.grammarElement), node) - Optional.of(convertedValue as String) - } catch (ValueConverterException e) { - Optional.empty - } - } -} \ No newline at end of file + private def getNSUri(INode node) { + try { + val convertedValue = valueConverterService.toValue(node.text, + linkingHelper.getRuleNameFrom(node.grammarElement), node) + Optional.of(convertedValue as String) + } catch (ValueConverterException e) { + Optional.empty + } + } + + private def getCftModel(CftImport context, INode node) { + getByUri(context, cftImport_ImportedCft, node) + } +} diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend index 36948c2d..b049b4c9 100644 --- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend +++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/scoping/ApplicationConfigurationScopeProvider.xtend @@ -3,28 +3,27 @@ */ package hu.bme.mit.inf.dslreasoner.application.scoping -import com.google.common.base.Function -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPackageEntry -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPatternEntry -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassReference +import com.google.inject.Inject +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.CftImport import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.EPackageImport import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelElement -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternElement -import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternEntry +import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ReliabiltiyFunction import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport +import hu.bme.mit.inf.dslreasoner.faulttree.components.cftLanguage.CftModel import org.eclipse.emf.ecore.EClass import org.eclipse.emf.ecore.EEnum import org.eclipse.emf.ecore.EObject import org.eclipse.emf.ecore.EReference import org.eclipse.viatra.query.patternlanguage.emf.vql.PatternModel import org.eclipse.xtext.EcoreUtil2 -import org.eclipse.xtext.naming.QualifiedName -import org.eclipse.xtext.scoping.IScope +import org.eclipse.xtext.naming.IQualifiedNameConverter import org.eclipse.xtext.scoping.Scopes +import static hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ApplicationConfigurationPackage.Literals.* + /** * This class contains custom scoping description. * @@ -32,150 +31,116 @@ import org.eclipse.xtext.scoping.Scopes * on how and when to use it. */ class ApplicationConfigurationScopeProvider extends AbstractApplicationConfigurationScopeProvider { - - private val language = ApplicationConfigurationPackage.eINSTANCE - protected val nameConverter = new Function() { - override apply(PatternModel input) { - println(input) - val res = QualifiedName.create(input.packageName.split("\\.")) - println(res.toString) - return res - } - } - + + @Inject IQualifiedNameConverter qualifiedNameConverter + override getScope(EObject context, EReference reference) { - val document = EcoreUtil2.getContainerOfType(context,ConfigurationScript) - if(context instanceof MetamodelElement) { - return context.scopeForMetamodelElement(reference,document) - } else if(context instanceof MetamodelSpecification) { - return context.scopeForMetamodelSpecification(reference,document) - } else if(context instanceof AllPackageEntry){ - return context.scopeForAllPackageEntry(reference,document) - } else if(context instanceof PatternElement) { - return context.scopeForPatternElement(reference,document) - } else if(context instanceof PatternSpecification) { - return context.scopeForPatternSpecification(reference,document) - } else if(context instanceof AllPatternEntry) { - return context.scopeForAllPatternEntry(reference,document) - } else if(context instanceof ClassReference) { - return context.scopeForClassReference(reference,document) - }else { - return super.getScope(context,reference) + val document = EcoreUtil2.getContainerOfType(context, ConfigurationScript) + switch (reference) { + case METAMODEL_ENTRY__PACKAGE: + getEPackageScope(document) + case METAMODEL_ELEMENT__CLASSIFIER: + getEClassifierScope(context, document) + case METAMODEL_ELEMENT__FEATURE: + getEStructuralFeatureScope(context, reference, document) + case PATTERN_ENTRY__PACKAGE: + getViatraPackageScope(context, reference, document) + case PATTERN_ELEMENT__PATTERN: + getViatraPatternScope(context, document) + case RELIABILTIY_FUNCTION__PACKAGE: + getCftPackageScope(context, reference, document) + case RELIABILTIY_FUNCTION__TRANSFORMATION: + getCftTransformationScope(context, document) + default: + super.getScope(context, reference) } } - - private def allEPackages(ConfigurationScript document) { - return document.imports.filter(EPackageImport).map[it.importedPackage].filterNull + + private def getAllEPackages(ConfigurationScript document) { + document.imports.filter(EPackageImport).map[importedPackage].filterNull } - private def allViatraPackages(ConfigurationScript document) { - val res = document.imports.filter(ViatraImport).map[it.importedViatra].filterNull - //println('''All packages: «res.map[packageName].toList»''') - return res + + private def getAllViatraPackages(ConfigurationScript document) { + document.imports.filter(ViatraImport).map[importedViatra].filterNull } - private def allEClassifiers(ConfigurationScript document) { + + private def getAllEClassifiers(ConfigurationScript document) { document.allEPackages.map[EClassifiers].flatten } - private def allPatterns(ConfigurationScript document) { - val res = document.allViatraPackages.map[patterns].flatten - //println('''All patterns: «res.map[name].toList»''') - return res + + private def getAllPatterns(ConfigurationScript document) { + document.allViatraPackages.map[patterns].flatten } - protected def scopeForMetamodelElement(MetamodelElement context, EReference reference, ConfigurationScript document) { - if(reference === language.metamodelEntry_Package) { - return Scopes.scopeFor(document.allEPackages) - } else if(reference === language.metamodelElement_Classifier) { - if(context.package !== null) { - return Scopes.scopeFor(context.package.EClassifiers) - } else { - return Scopes.scopeFor(document.allEClassifiers) - } - } if (reference === language.metamodelElement_Feature) { - val referredClassifier = context.classifier - if(referredClassifier instanceof EClass) { - return Scopes.scopeFor(referredClassifier.EAllStructuralFeatures) - } else if(referredClassifier instanceof EEnum) { - return Scopes.scopeFor(referredClassifier.ELiterals) - } else { - super.getScope(context,reference) - } - } + private def getAllCftPackages(ConfigurationScript document) { + document.imports.filter(CftImport).map[importedCft].filterNull } - - protected def scopeForMetamodelSpecification(MetamodelSpecification context, EReference reference, ConfigurationScript document) { - if(reference === language.metamodelEntry_Package) { - return Scopes.scopeFor(document.allEPackages) - } else if(reference ===language.metamodelElement_Classifier) { - return Scopes.scopeFor(document.allEClassifiers) - } else { - return super.getScope(context,reference) - } + + private def getAllCftTransformations(ConfigurationScript document) { + document.allCftPackages.map[transformationDefinitions].flatten } - - protected def scopeForAllPackageEntry(AllPackageEntry context, EReference reference, ConfigurationScript document) { - if(reference === language.metamodelEntry_Package) { - return Scopes.scopeFor(document.allEPackages) - } else if(reference === language.metamodelElement_Classifier) { - if(context.package === null) { - return Scopes.scopeFor(document.allEClassifiers) - } else { - return Scopes.scopeFor(context.package.EClassifiers) - } - } else { - return super.getScope(context,reference) - } + + private def getEPackageScope(ConfigurationScript document) { + Scopes.scopeFor(document.allEPackages) } - - ////////// - - def IScope scopeForClassReference(ClassReference classReference, EReference eReference, ConfigurationScript document) { - if(eReference === language.metamodelEntry_Package) { - return Scopes.scopeFor(document.allEPackages) - } else if(eReference === language.metamodelElement_Classifier) { - Scopes.scopeFor(document.allEClassifiers) - } else { - return super.getScope(classReference,eReference) + + private def getEClassifierScope(EObject context, ConfigurationScript document) { + val classifiers = switch (context) { + MetamodelEntry case context.package !== null: + context.package.EClassifiers + default: + document.allEClassifiers } + Scopes.scopeFor(classifiers) } - - ////////// - - protected def scopeForPatternElement(PatternElement context, EReference reference, ConfigurationScript document) { - if(reference === language.patternEntry_Package) { - return Scopes.scopeFor(document.allViatraPackages,nameConverter,super.getScope(context,reference)) - } else if(reference === language.patternElement_Pattern) { - if(context.package !== null) { - return Scopes.scopeFor(context.package.patterns) + + private def getEStructuralFeatureScope(EObject context, EReference reference, ConfigurationScript document) { + val referredClassifier = if (context instanceof MetamodelElement) { + context.classifier } else { - return Scopes.scopeFor(document.allPatterns) + null } - } else { - super.getScope(context,reference) + switch (referredClassifier) { + EClass: + Scopes.scopeFor(referredClassifier.EAllStructuralFeatures) + EEnum: + Scopes.scopeFor(referredClassifier.ELiterals) + default: + super.getScope(context, reference) } } - - protected def scopeForPatternSpecification(PatternSpecification context, EReference reference, ConfigurationScript document) { - if(reference === language.patternEntry_Package) { - return Scopes.scopeFor(document.allViatraPackages,nameConverter,super.getScope(context,reference)) - } else if(reference ===language.patternElement_Pattern) { - return Scopes.scopeFor(document.allPatterns) - } else { - return super.getScope(context,reference) + + private def getViatraPackageScope(EObject context, EReference reference, ConfigurationScript document) { + val patternModelNameConverter = [ PatternModel patternModel | + qualifiedNameConverter.toQualifiedName(patternModel.packageName) + ] + Scopes.scopeFor(document.allViatraPackages, patternModelNameConverter, super.getScope(context, reference)) + } + + private def getViatraPatternScope(EObject context, ConfigurationScript document) { + val patterns = switch (context) { + PatternEntry case context.package !== null: + context.package.patterns + default: + document.allPatterns } + Scopes.scopeFor(patterns) } - - protected def scopeForAllPatternEntry(AllPatternEntry context, EReference reference, ConfigurationScript document) { - if(reference === language.patternEntry_Package) { - val res = Scopes.scopeFor(document.allViatraPackages,nameConverter,super.getScope(context,reference)) - return res - } else if(reference === language.patternElement_Pattern) { - if(context.package === null) { - return Scopes.scopeFor(document.allPatterns) - } else { - return Scopes.scopeFor(context.package.patterns) - } - } else { - return super.getScope(context,reference) + + private def getCftPackageScope(EObject context, EReference reference, ConfigurationScript document) { + val cftModelNameConverter = [ CftModel cftModel | + qualifiedNameConverter.toQualifiedName(cftModel.packageName) + ] + Scopes.scopeFor(document.allCftPackages, cftModelNameConverter, super.getScope(context, reference)) + } + + private def getCftTransformationScope(EObject context, ConfigurationScript document) { + val transformations = switch (context) { + ReliabiltiyFunction case context.package !== null: + context.package.transformationDefinitions + default: + document.allCftTransformations } + Scopes.scopeFor(transformations) } } -- cgit v1.2.3-70-g09d2