blob: c25bfb0728ac78df3f3b792d8ac2046759c90d20 (
plain) (
blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
|
package hu.bme.mit.inf.dslreasoner.application.execution
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.AllPatternEntry
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ConfigurationScript
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternElement
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternEntry
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.PatternSpecification
import hu.bme.mit.inf.dslreasoner.application.applicationConfiguration.ViatraImport
import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor
import java.util.HashMap
import java.util.LinkedHashSet
import java.util.List
import java.util.Set
import org.eclipse.emf.ecore.EClass
import org.eclipse.emf.ecore.EPackage
import org.eclipse.viatra.query.patternlanguage.emf.specification.SpecificationBuilder
import org.eclipse.viatra.query.patternlanguage.emf.vql.Pattern
import org.eclipse.viatra.query.patternlanguage.emf.vql.PatternCompositionConstraint
import org.eclipse.viatra.query.patternlanguage.emf.vql.PatternModel
import org.eclipse.viatra.query.runtime.api.IQuerySpecification
import org.eclipse.xtext.EcoreUtil2
import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
class QueryLoader {
//val parser = new VQLParser
val builder = new SpecificationBuilder
def loadQueries(PatternSpecification specification) {
val patterns = new LinkedHashSet
for(entry: specification.entries) {
patterns += getPatterns(entry)
}
val allConcernedPatterns = patterns.allReferredPatterns
val pattern2Specification = allConcernedPatterns.translatePatterns()
val List<IQuerySpecification<?>> patternsToTranslate =
pattern2Specification.values.toList
val Set<IQuerySpecification<?>> validationPatterns =
patterns.filter[it.annotations.exists[it.name.equals("Constraint")]]
.map[lookup(pattern2Specification)]
.toSet
val derivedFeatures = calculateDerivedFeatures(patterns.referredEcoreModels,patterns.map[it.lookup(pattern2Specification)])
return new ViatraQuerySetDescriptor(
patternsToTranslate,
validationPatterns,
derivedFeatures
) -> allConcernedPatterns
}
def dispatch List<Pattern> getPatterns(AllPatternEntry entry) {
val excluded = entry.exclusuion.map[getPatterns]
val referredPatternModels = allPatternsWithSamePackage(entry,entry.package as PatternModel).toSet
val patterns = referredPatternModels.map[patterns].flatten
return patterns.filter[!excluded.contains(it)].toList
}
def dispatch List<Pattern> getPatterns(PatternElement entry) {
return #[entry.pattern]
}
def private allPatternsWithSamePackage(PatternEntry entry, PatternModel model) {
val packageURI = model.packageName
val document = EcoreUtil2.getContainerOfType(entry,ConfigurationScript)
val viatraImportsWithSamePackage = document.imports
.filter(ViatraImport)
.map[it.importedViatra]
.filterNull
.filter[packageName.equals(packageURI)]
return viatraImportsWithSamePackage
}
/**
* Adds all referred patterns to a given set of patterns.
*/
def private Set<Pattern> allReferredPatterns(Set<Pattern> patterns) {
val res = new LinkedHashSet
res+=patterns
var boolean changed
do{
changed = false
val newElements = res.map[directlyReferredPatterns].flatten.filter[!res.contains(it)]
if(!newElements.empty) {
changed = true
res.addAll(newElements)
}
} while(changed)
return res
}
def private directlyReferredPatterns(Pattern pattern) {
return pattern
.bodies
.map[constraints]
.flatten
.filter(PatternCompositionConstraint)
.map[call.patternRef].toSet
}
def private referredEcoreModels(Set<Pattern> patterns) {
patterns.map[eContainer as PatternModel].map[it.importPackages.packageImport.map[it.EPackage].filterNull].flatten.toSet
}
def private translatePatterns(Set<Pattern> xtextPattern) {
xtextPattern.toInvertedMap[builder.getOrCreateSpecification(it) as IQuerySpecification<?>]
}
def private calculateDerivedFeatures(Set<EPackage> packages, Iterable<IQuerySpecification<?>> patterns) {
val features = packages.map[EClassifiers].flatten.filter(EClass).map[it.EStructuralFeatures].flatten
val res = new HashMap
for(feature : features) {
val QBFAnnotation = feature.EAnnotations.filter[it.source.equals("org.eclipse.viatra.query.querybasedfeature")].head
if(QBFAnnotation !== null) {
val targetFQN = QBFAnnotation.details.get("patternFQN")
val referredPattern = patterns.filter[
val fqn = it.fullyQualifiedName
fqn.equals(targetFQN)
].head
if(referredPattern!== null) {
res.put(referredPattern, feature)
}
}
}
return res
}
}
|