aboutsummaryrefslogtreecommitdiffstats
path: root/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution
diff options
context:
space:
mode:
authorLibravatar OszkarSemerath <oszkar.semerath@gmail.com>2018-01-24 11:42:29 +0100
committerLibravatar OszkarSemerath <oszkar.semerath@gmail.com>2018-01-24 11:42:29 +0100
commit7b40388ea6bb96ab3adacf338b1bc30d06474df4 (patch)
treee925aafff7f40a6f1a82a1f5b653d625f3308878 /Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution
parentNew Scope format: #String += 2..* (diff)
downloadVIATRA-Generator-7b40388ea6bb96ab3adacf338b1bc30d06474df4.tar.gz
VIATRA-Generator-7b40388ea6bb96ab3adacf338b1bc30d06474df4.tar.zst
VIATRA-Generator-7b40388ea6bb96ab3adacf338b1bc30d06474df4.zip
Loading services
Diffstat (limited to 'Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution')
-rw-r--r--Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend4
-rw-r--r--Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend220
-rw-r--r--Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend124
-rw-r--r--Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/MetamodelValidator.xtend76
-rw-r--r--Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/QueryAndMetamodelValidator.xtend53
5 files changed, 327 insertions, 150 deletions
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend
index 8f72caed..c00c0d31 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/Context.xtend
@@ -1,9 +1,5 @@
1package hu.bme.mit.inf.dslreasoner.application.execution 1package hu.bme.mit.inf.dslreasoner.application.execution
2 2
3import java.io.OutputStream
4import java.util.LinkedList
5import java.util.List
6import java.io.FileWriter
7import org.eclipse.xtend.lib.annotations.Accessors 3import org.eclipse.xtend.lib.annotations.Accessors
8 4
9class Context { 5class Context {
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend
index 126dbb7d..e554cc69 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/MetamodelLoader.xtend
@@ -1,15 +1,10 @@
1package hu.bme.mit.inf.dslreasoner.application.execution 1package hu.bme.mit.inf.dslreasoner.application.execution
2 2
3import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ClassElement
4import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.FeatureElement
5import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry
6import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification 3import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelSpecification
7import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor 4import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor
8import java.util.ArrayList 5import java.util.ArrayList
9import java.util.HashMap
10import java.util.LinkedList 6import java.util.LinkedList
11import java.util.List 7import java.util.List
12import java.util.Map
13import java.util.Set 8import java.util.Set
14import org.eclipse.emf.common.util.URI 9import org.eclipse.emf.common.util.URI
15import org.eclipse.emf.ecore.EAttribute 10import org.eclipse.emf.ecore.EAttribute
@@ -24,13 +19,11 @@ import org.eclipse.emf.ecore.EcorePackage
24import org.eclipse.emf.ecore.resource.Resource 19import org.eclipse.emf.ecore.resource.Resource
25import org.eclipse.emf.ecore.resource.ResourceSet 20import org.eclipse.emf.ecore.resource.ResourceSet
26import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl 21import org.eclipse.emf.ecore.xmi.impl.XMIResourceFactoryImpl
27import org.eclipse.xtend.lib.annotations.Data 22import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPackageEntry
28 23import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelElement
29@Data 24import org.eclipse.xtext.xbase.lib.Functions.Function1
30class Metamodel { 25import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.MetamodelEntry
31 List<EPackage> packages 26import java.util.LinkedHashSet
32 EcoreMetamodelDescriptor descriptor
33}
34 27
35class MetamodelLoader { 28class MetamodelLoader {
36 29
@@ -41,138 +34,97 @@ class MetamodelLoader {
41 34
42 public new() { init } 35 public new() { init }
43 36
44 def loadMetamodel(List<String> specification, ResourceSet rs, Context context) { 37 def loadMetamodel(MetamodelSpecification specification, ResourceSet rs) throws IllegalArgumentException {
45 38
46 } 39 val Set<EClass> classes = new LinkedHashSet
47 40 val Set<EEnum> enums = new LinkedHashSet
48 def loadMetamodel(MetamodelSpecification specification, ResourceSet rs, Context context) { 41 val Set<EEnumLiteral> literals = new LinkedHashSet
49 val Map<MetamodelEntry,List<EPackage>> entry2Packages = new HashMap 42 val Set<EReference> references = new LinkedHashSet
43 val Set<EAttribute> attributes = new LinkedHashSet
50 44
45 /** Add all included types */
51 for(entry : specification.entries) { 46 for(entry : specification.entries) {
52 val packagesInEntry = entry.path.path.loadPackageFromPath(rs,context) 47 classes+=entry.classes
53 entry2Packages.put(entry,packagesInEntry) 48 enums+=entry.enums
49 literals+=entry.literals
50 references+=entry.references
51 attributes+=entry.attributes
54 } 52 }
55 53
56 return entry2Packages 54 return new EcoreMetamodelDescriptor(classes.toList, emptySet, false, enums.toList, literals.toList, references.toList, attributes.toList)
57 } 55 }
58 56
59 public def pruneMetamodel(Map<MetamodelEntry,List<EPackage>> specification, ResourceSet rs, Context context) { 57 def <T> List<T> extractElements(MetamodelEntry entry, Function1<AllPackageEntry,Iterable<T>> packageEntryExtractor, Function1<MetamodelElement,Iterable<T>> metamodelElementExtractor) {
60 val List<EClass> classes = new LinkedList 58 if(entry instanceof MetamodelElement) {
61 val List<EEnum> enums = new LinkedList 59 return metamodelElementExtractor.apply(entry).toList
62 val List<EEnumLiteral> literals = new LinkedList 60 } else if(entry instanceof AllPackageEntry) {
63 val List<EReference> references = new LinkedList 61 val excluded = entry.exclusion.map[metamodelElementExtractor.apply(it)].flatten.toSet
64 val List<EAttribute> attributes = new LinkedList 62 return packageEntryExtractor.apply(entry).filter[!excluded.contains(it)].toList
65 63 } else throw new IllegalArgumentException('''Unsupported entry type: "«entry.class.simpleName»"!''')
66
67 /** Add all included types */
68 for(entry : specification.entrySet) {
69 val metamodelEntry = entry.key
70 val packages = entry.value
71
72 /** Excluted types */
73 val excludedTypeNames = metamodelEntry.excluding.filter(ClassElement).map[name].toSet
74 /** Excluded features */
75 val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet
76
77 /** Load the types */
78 for(package : packages) {
79 for(class : package.EClassifiers.filter(EClass)) {
80 classes.addIfNotExcluded(class,excludedTypeNames)
81 }
82 for(enum : package.EClassifiers.filter(EEnum)) {
83 val added = enums.addIfNotExcluded(enum,excludedTypeNames)
84 if(added) {
85 for(literal : enum.ELiterals) {
86 literals.addIfNotExcluded(literal,enum,excludedFeatureNames)
87 }
88 }
89 }
90 }
91 }
92
93 /** Add all included references and attributes*/
94 for(entry : specification.entrySet) {
95 val metamodelEntry = entry.key
96 val packages = entry.value
97
98 /** Excluded features */
99 val excludedFeatureNames = metamodelEntry.excluding.filter(FeatureElement).map[it.container.name -> it.name].toSet
100
101 /** See if type is included */
102 for(package : packages) {
103 for(class : package.EClassifiers.filter(EClass)) {
104 if(classes.contains(class)) {
105 for(reference : class.EReferences) {
106 if(classes.contains(reference.EType)) {
107 references.addIfNotExcluded(reference,class,excludedFeatureNames)
108 }
109 }
110 for(attribute : class.EAttributes) {
111 val type = attribute.EType
112 if(type instanceof EEnum) {
113 if(enums.contains(type)) {
114 attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
115 } else if(type == EcorePackage.Literals) {
116 if(enums.contains(type)) {
117 attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
118 }
119 }
120 } else if(supportedEDataType(type as EDataType)) {
121 attributes.addIfNotExcluded(attribute,class,excludedFeatureNames)
122 }
123 }
124 }
125 }
126 }
127 }
128 } 64 }
129 65
130 private def supportedEDataType(EDataType dataType) { 66 def getClasses(MetamodelEntry entry) {
131 val extension l = EcorePackage.eINSTANCE 67 return entry.extractElements(
132 return #[EInt, EBoolean, EString, EDouble, EFloat].contains(dataType) 68 [package.EClassifiers.filter(EClass)],
69 [val classifier = it.classifier
70 if(classifier instanceof EClass){ if(it.feature === null) { return #[classifier]} }
71 return emptyList
72 ]
73 )
133 } 74 }
134 75 def getEnums(MetamodelEntry entry) {
135 private def <T extends ENamedElement> addIfNotExcluded( 76 return entry.extractElements(
136 List<T> target, 77 [package.EClassifiers.filter(EEnum)],
137 T element, 78 [val classifier = it.classifier
138 Set<String> excluded) 79 if(classifier instanceof EEnum){ if(it.feature === null) { return #[classifier]} }
139 { 80 return emptyList
140 if(excluded.contains(element.name)) { 81 ]
141 target += element 82 )
142 return true
143 } else {
144 return false
145 }
146 } 83 }
147 private def <T1 extends ENamedElement> addIfNotExcluded( 84 def getLiterals(MetamodelEntry entry) {
148 List<T1> target, 85 return entry.extractElements(
149 T1 element, 86 [package.EClassifiers.filter(EEnum).map[ELiterals].flatten],
150 ENamedElement container, 87 [val feature = it.feature
151 Set<Pair<String,String>> excluded) 88 if(feature instanceof EEnumLiteral){ return #[feature] }
152 { 89 return emptyList
153 val pair = (container.name) -> (element.name) 90 ]
154 91 )
155 if(excluded.contains(pair)) {
156 target += element
157 }
158 } 92 }
159 93 def getReferences(MetamodelEntry entry) {
160 private def List<EPackage> loadPackageFromPath(String path, ResourceSet rs, Context context) throws RuntimeException { 94 return entry.extractElements(
161 var Resource resource; 95 [package.EClassifiers.filter(EClass).map[EReferences].flatten],
162 try{ 96 [val feature = it.feature
163 resource = rs.getResource(URI.createURI(path),true) 97 if(feature instanceof EReference) { return #[feature] }
164 } catch(RuntimeException e) { 98 return emptyList
165 context.writeError('''Unable to load EPackage: Error in path "«path»"!''') 99 ]
166 return #[] 100 )
167 }
168 val res = new ArrayList<EPackage>(resource.contents.size)
169 for(content: resource.contents) {
170 if(content instanceof EPackage) {
171 res += content
172 } else {
173 context.writeError('''Unable to load EPackage: The content of "«path»" is not an EPackage, but "«content.eClass.name»"!''')
174 }
175 }
176 return res
177 } 101 }
102 def getAttributes(MetamodelEntry entry) {
103 return entry.extractElements(
104 [package.EClassifiers.filter(EClass).map[EAttributes].flatten],
105 [val feature = it.feature
106 if(feature instanceof EAttribute) {return #[feature]}
107 return emptyList
108 ]
109 )
110 }
111
112// public def List<EPackage> loadPackageFromPath(String path, ResourceSet rs, Context context) throws RuntimeException {
113// var Resource resource;
114// try{
115// resource = rs.getResource(URI.createURI(path),true)
116// } catch(RuntimeException e) {
117// context.writeError('''Unable to load EPackage: Error in path "«path»"!''')
118// return #[]
119// }
120// val res = new ArrayList<EPackage>(resource.contents.size)
121// for(content: resource.contents) {
122// if(content instanceof EPackage) {
123// res += content
124// } else {
125// context.writeError('''Unable to load EPackage: The content of "«path»" is not an EPackage, but "«content.eClass.name»"!''')
126// }
127// }
128// return res
129// }
178} \ No newline at end of file 130} \ No newline at end of file
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend
index 8c064cd3..6e725086 100644
--- a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/QueryLoader.xtend
@@ -1,28 +1,128 @@
1package hu.bme.mit.inf.dslreasoner.application.execution 1package hu.bme.mit.inf.dslreasoner.application.execution
2 2
3import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPatternEntry
4import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript
5import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternElement
6import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternEntry
3import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification 7import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification
4import hu.bme.mit.inf.dslreasoner.application.execution.util.VQLParser 8import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport
5import java.util.LinkedHashMap 9import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor
6import org.eclipse.emf.ecore.resource.ResourceSet 10import java.util.HashMap
11import java.util.LinkedHashSet
12import java.util.List
13import java.util.Set
14import org.eclipse.emf.ecore.EClass
15import org.eclipse.emf.ecore.EPackage
16import org.eclipse.viatra.query.patternlanguage.emf.eMFPatternLanguage.PatternModel
17import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder
18import org.eclipse.viatra.query.patternlanguage.patternLanguage.Pattern
19import org.eclipse.viatra.query.patternlanguage.patternLanguage.PatternCompositionConstraint
20import org.eclipse.viatra.query.runtime.api.IQuerySpecification
21import org.eclipse.xtext.EcoreUtil2
7 22
8import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* 23import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
9 24
10class QueryLoader { 25class QueryLoader {
11 val parser = new VQLParser 26 //val parser = new VQLParser
27 val builder = new SpecificationBuilder
12 28
13 def loadQueries(PatternSpecification specification, ResourceSet rs, Context context) { 29 def loadQueries(PatternSpecification specification) {
14 val uris = specification.entries.map[path].toList 30 val patterns = new LinkedHashSet
15 val models = parser.parse(uris,rs,context)
16 31
17 val res = new LinkedHashMap 32 for(entry: specification.entries) {
18 for(entry : specification.entries) { 33 patterns += getPatterns(entry)
19 res.put(entry,entry.path.lookup(models))
20 } 34 }
21 35
22 return res 36 val allConcernedPatterns = patterns.allReferredPatterns
37 val pattern2Specification = allConcernedPatterns.translatePatterns()
38
39 val List<IQuerySpecification<?>> patternsToTranslate =
40 pattern2Specification.values.toList
41 val Set<IQuerySpecification<?>> validationPatterns =
42 patterns.filter[it.annotations.exists[it.name.equals("Constraint")]]
43 .map[lookup(pattern2Specification)]
44 .toSet
45 val derivedFeatures = calculateDerivedFeatures(patterns.referredEcoreModels,patterns.map[it.lookup(pattern2Specification)])
46
47 return new ViatraQuerySetDescriptor(
48 patternsToTranslate,
49 validationPatterns,
50 derivedFeatures
51 ) -> allConcernedPatterns
23 } 52 }
24 53
25 def pruneQueries(PatternSpecification specification, ResourceSet rs, Context context) { 54 def dispatch List<Pattern> getPatterns(AllPatternEntry entry) {
55 val excluded = entry.exclusuion.map[getPatterns]
56 val referredPatternModels = allPatternsWithSamePackage(entry,entry.package as PatternModel).toSet
57 val patterns = referredPatternModels.map[patterns].flatten
58 return patterns.filter[!excluded.contains(it)].toList
59 }
60
61 def dispatch List<Pattern> getPatterns(PatternElement entry) {
62 return #[entry.pattern]
63 }
64
65 def private allPatternsWithSamePackage(PatternEntry entry, PatternModel model) {
66 val packageURI = model.packageName
67 val document = EcoreUtil2.getContainerOfType(entry,ConfigurationScript)
68 val viatraImportsWithSamePackage = document.imports
69 .filter(ViatraImport)
70 .map[it.importedViatra]
71 .filterNull
72 .filter[packageName.equals(packageURI)]
73 return viatraImportsWithSamePackage
74 }
75
76 /**
77 * Adds all referred patterns to a given set of patterns.
78 */
79 def private Set<Pattern> allReferredPatterns(Set<Pattern> patterns) {
80 val res = new LinkedHashSet
81 res+=patterns
26 82
83 var boolean changed
84 do{
85 changed = false
86 val newElements = res.map[directlyReferredPatterns].flatten.filter[!res.contains(it)]
87 if(!newElements.empty) {
88 changed = true
89 res.addAll(newElements)
90 }
91 } while(changed)
92
93 return res
94 }
95
96 def private directlyReferredPatterns(Pattern pattern) {
97 return pattern
98 .bodies
99 .map[constraints]
100 .flatten
101 .filter(PatternCompositionConstraint)
102 .map[call.patternRef].toSet
103 }
104
105 def private referredEcoreModels(Set<Pattern> patterns) {
106 patterns.map[eContainer as PatternModel].map[it.importPackages.packageImport.map[it.EPackage].filterNull].flatten.toSet
107 }
108
109 def private translatePatterns(Set<Pattern> xtextPattern) {
110 xtextPattern.toInvertedMap[builder.getOrCreateSpecification(it) as IQuerySpecification<?>]
111 }
112
113 def private calculateDerivedFeatures(Set<EPackage> packages, Iterable<IQuerySpecification<?>> patterns) {
114 val features = packages.map[EClassifiers].flatten.filter(EClass).map[it.EStructuralFeatures].flatten
115 val res = new HashMap
116 for(feature : features) {
117 val QBFAnnotation = feature.EAnnotations.filter[it.source.equals("org.eclipse.viatra.query.querybasedfeature")].head
118 if(QBFAnnotation !== null) {
119 val targetFQN = QBFAnnotation.details.get("patternFQN")
120 val referredPattern = patterns.filter[it.fullyQualifiedName.equals(targetFQN)].head
121 if(referredPattern!== null) {
122 res.put(referredPattern, feature)
123 }
124 }
125 }
126 return res
27 } 127 }
28} \ No newline at end of file 128} \ No newline at end of file
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/MetamodelValidator.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/MetamodelValidator.xtend
new file mode 100644
index 00000000..aae47c83
--- /dev/null
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/MetamodelValidator.xtend
@@ -0,0 +1,76 @@
1package hu.bme.mit.inf.dslreasoner.application.execution.validation
2
3import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor
4import java.util.LinkedList
5import java.util.List
6import org.eclipse.emf.ecore.EAttribute
7import org.eclipse.emf.ecore.EClass
8import org.eclipse.emf.ecore.EDataType
9import org.eclipse.emf.ecore.EEnum
10import org.eclipse.emf.ecore.EEnumLiteral
11import org.eclipse.emf.ecore.EReference
12import org.eclipse.emf.ecore.EcorePackage
13
14class MetamodelValidator {
15 def validateMetamodel(EcoreMetamodelDescriptor descriptor) {
16 val errors = new LinkedList
17 this.allSupertypesAreIncluded(descriptor.classes,errors)
18 this.allEnumTypesareIncluded(descriptor.enums,descriptor.literals,errors)
19 this.referenceEndpointsAreIncluded(descriptor.classes,descriptor.references,errors)
20 this.attributeSourcePontIsIncluded(descriptor.classes,descriptor.attributes,errors)
21 this.attributeTargetIsSupported(descriptor.attributes,errors)
22 return errors
23 }
24
25
26 private def supportedEDataType(EDataType dataType) {
27 val extension l = EcorePackage.eINSTANCE
28 return #[EInt, EBoolean, EString, EDouble, EFloat].contains(dataType)
29 }
30
31 def allSupertypesAreIncluded(List<EClass> classes, List<String> errors) {
32 for(c : classes) {
33 for(s : c.ESuperTypes) {
34 if(!classes.contains(s)) {
35 errors.add('''Metamodel contains "«c.name»" but not contains its supertype "«s.name»"!''')
36 }
37 }
38 }
39 }
40 def allEnumTypesareIncluded(List<EEnum> enums, List<EEnumLiteral> literals, List<String> errors) {
41 for(l: literals) {
42 if(!enums.contains(l.EEnum)) {
43 errors.add('''Metamodel contains literal "«l.name»" but does not contains enum "«l.EEnum.name»"!''')
44 }
45 }
46 }
47 def referenceEndpointsAreIncluded(List<EClass> classes, List<EReference> references, List<String> errors) {
48 for(reference : references) {
49 val src = reference.EContainingClass
50 if(!classes.contains(src)) {
51 errors.add('''Metamodel contains reference "«reference.name»" but does not contains its source type "«src.name»"!''')
52 }
53
54 val trg = reference.EReferenceType
55 if(!classes.contains(trg)) {
56 errors.add('''Metamodel contains reference "«reference.name»" but does not contains its target type "«trg.name»"!''')
57 }
58 }
59 }
60 def attributeSourcePontIsIncluded(List<EClass> classes, List<EAttribute> attributes, List<String> errors) {
61 for(attribute : attributes) {
62 val src = attribute.containerClass
63 if(!classes.contains(src)) {
64 errors.add('''Metamodel contains attribute "«attribute.name»" but does not contains its source type "«src.name»"!''')
65 }
66 }
67 }
68 def attributeTargetIsSupported(List<EAttribute> attributes, List<String> errors) {
69 for(attribute: attributes) {
70 val trg = attribute.EAttributeType
71 if(!supportedEDataType(trg)) {
72 errors.add('''Metamodels contains attribute "«attribute.name»" with unsupported type "«trg.name»"!''')
73 }
74 }
75 }
76} \ No newline at end of file
diff --git a/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/QueryAndMetamodelValidator.xtend b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/QueryAndMetamodelValidator.xtend
new file mode 100644
index 00000000..e1a20ffd
--- /dev/null
+++ b/Application/hu.bme.mit.inf.dslreasoner.application/src/hu/bme/mit/inf/dslreasoner/application/execution/validation/QueryAndMetamodelValidator.xtend
@@ -0,0 +1,53 @@
1package hu.bme.mit.inf.dslreasoner.application.execution.validation
2
3import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor
4import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor
5import java.util.List
6import java.util.Set
7import org.eclipse.emf.ecore.ENamedElement
8import org.eclipse.viatra.query.patternlanguage.patternLanguage.Pattern
9import org.eclipse.viatra.query.runtime.api.IQuerySpecification
10import java.util.LinkedList
11
12class QueryAndMetamodelValidator {
13
14 def public validateQueryAndMetamodel(
15 EcoreMetamodelDescriptor metamodel,
16 Pair<ViatraQuerySetDescriptor, Set<Pattern>> viatra)
17 {
18 val patterns = viatra.value
19 val elementsInMetamodel =
20 (metamodel.classes +
21 metamodel.enums +
22 metamodel.literals+
23 metamodel.attributes +
24 metamodel.references)
25 .toSet
26 val errors = new LinkedList
27 for(pattern : patterns) {
28 val elements = getReferredNamedElements(pattern)
29 for(element : elements) {
30 if(!elementsInMetamodel.contains(element)) {
31 errors+='''Pattern "«pattern.name»" refers to an element "«element»" that is not included to the selected metamodel!'''
32 }
33 }
34 }
35 return errors
36 }
37
38 def getReferredNamedElements(Pattern pattern) {
39 val elements = pattern.eAllContents.toList
40 return elements.map[element|
41 val references = element.eClass.EAllReferences
42 return references.map[r |
43 if(r.isMany) {
44 return (element.eGet(r) as List<?>).filter(ENamedElement)
45 } else {
46 val value = element.eGet(r)
47 if(value instanceof ENamedElement) return #[value]
48 else return #[]
49 }
50 ].flatten.filter(ENamedElement)
51 ].flatten
52 }
53} \ No newline at end of file
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-06-29 03:54:52 +0000