Fault tree transformation for partial models WIP

4 files changed, 215 insertions, 231 deletions

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

 ;

 

 ///////////////////////////////////////////////////

@@ -89,6 +92,23 @@ 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<EObject> 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<PatternModel,QualifiedName>() {

-                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)

         }

 }