aboutsummaryrefslogtreecommitdiffstats
path: root/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend
diff options
context:
space:
mode:
Diffstat (limited to 'Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend')
-rw-r--r--Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend391
1 files changed, 296 insertions, 95 deletions
diff --git a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend
index 43d145d3..bf9ca274 100644
--- a/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend
+++ b/Tests/hu.bme.mit.inf.dslreasoner.run/src/hu/bme/mit/inf/dslreasoner/run/MetamodelLoader.xtend
@@ -1,19 +1,26 @@
1package hu.bme.mit.inf.dslreasoner.run 1package hu.bme.mit.inf.dslreasoner.run
2 2
3import hu.bme.mit.inf.dslreasomer.domains.transima.fam.FunctionalArchitecture.FunctionalArchitecturePackage 3import functionalarchitecture.FunctionalarchitecturePackage
4import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Ecore
4import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.FileSystem 5import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.FileSystem
5import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FilesystemPackage 6import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FilesystemPackage
6import hu.bme.mit.inf.dslreasoner.domains.transima.fam.patterns.Pattern 7import hu.bme.mit.inf.dslreasoner.domains.satellite.queries.internal.SatelliteQueriesAll
8import hu.bme.mit.inf.dslreasoner.domains.transima.fam.FamPatterns
7import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.YakindummPackage 9import hu.bme.mit.inf.dslreasoner.domains.yakindu.sgraph.yakindumm.YakindummPackage
10import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic
11import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace
8import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor 12import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor
9import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns 13import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns
10import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor 14import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor
11import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod 15import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationMethod
16import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.LinearTypeConstraintHint
12import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethodBasedGlobalConstraint 17import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethodBasedGlobalConstraint
13import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace 18import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace
14import java.util.Collection 19import java.util.Collection
20import java.util.HashMap
15import java.util.LinkedHashMap 21import java.util.LinkedHashMap
16import java.util.List 22import java.util.List
23import java.util.Map
17import java.util.Set 24import java.util.Set
18import org.eclipse.emf.ecore.EAttribute 25import org.eclipse.emf.ecore.EAttribute
19import org.eclipse.emf.ecore.EClass 26import org.eclipse.emf.ecore.EClass
@@ -21,61 +28,91 @@ import org.eclipse.emf.ecore.EEnum
21import org.eclipse.emf.ecore.EEnumLiteral 28import org.eclipse.emf.ecore.EEnumLiteral
22import org.eclipse.emf.ecore.EObject 29import org.eclipse.emf.ecore.EObject
23import org.eclipse.emf.ecore.EReference 30import org.eclipse.emf.ecore.EReference
24import org.eclipse.xtext.xbase.lib.Functions.Function1
25import java.util.HashMap
26import org.eclipse.emf.ecore.EcorePackage 31import org.eclipse.emf.ecore.EcorePackage
27import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Ecore 32import org.eclipse.xtend.lib.annotations.Data
33import org.eclipse.xtext.xbase.lib.Functions.Function1
34import satellite.SatellitePackage
35
36@Data
37class TypeQuantiles {
38 double low
39 double high
40}
28 41
29abstract class MetamodelLoader { 42abstract class MetamodelLoader {
43 public static val UNSAT_PREFIX = "unsat_"
44
30 protected val ReasonerWorkspace workspace 45 protected val ReasonerWorkspace workspace
31 public new(ReasonerWorkspace workspace) { 46
47 new(ReasonerWorkspace workspace) {
32 this.workspace = workspace 48 this.workspace = workspace
33 } 49 }
50
34 def EcoreMetamodelDescriptor loadMetamodel() 51 def EcoreMetamodelDescriptor loadMetamodel()
52
35 def Set<EClass> getRelevantTypes(EcoreMetamodelDescriptor descriptor) 53 def Set<EClass> getRelevantTypes(EcoreMetamodelDescriptor descriptor)
54
36 def Set<EReference> getRelevantReferences(EcoreMetamodelDescriptor descriptor) 55 def Set<EReference> getRelevantReferences(EcoreMetamodelDescriptor descriptor)
56
37 def ViatraQuerySetDescriptor loadQueries(EcoreMetamodelDescriptor metamodel) 57 def ViatraQuerySetDescriptor loadQueries(EcoreMetamodelDescriptor metamodel)
58
38 def List<EObject> loadPartialModel() 59 def List<EObject> loadPartialModel()
60
61 def List<Function1<ModelGenerationMethod, ModelGenerationMethodBasedGlobalConstraint>> additionalConstraints()
62
63 def Map<String, TypeQuantiles> getTypeQuantiles() {
64 emptyMap
65 }
39 66
40 def List<Function1<ModelGenerationMethod,ModelGenerationMethodBasedGlobalConstraint>> additionalConstraints() 67 def Map<String, TypeQuantiles> getUnsatTypeQuantiles() {
41 68 throw new UnsupportedOperationException("This domain has no type quantiles for unsatisfiable problems")
42 def <T> filterByNames(Iterable<T> collection, Function1<T,String> nameExtractor, Collection<String> requiredNames) { 69 }
70
71 def List<LinearTypeConstraintHint> getHints(Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) {
72 emptyList
73 }
74
75 def <T> filterByNames(Iterable<T> collection, Function1<T, String> nameExtractor,
76 Collection<String> requiredNames) {
43 val res = collection.filter[requiredNames.contains(nameExtractor.apply(it))] 77 val res = collection.filter[requiredNames.contains(nameExtractor.apply(it))]
44 if(res.size != requiredNames.size) throw new IllegalArgumentException 78 if(res.size != requiredNames.size) throw new IllegalArgumentException
45 return res.toSet 79 return res.toSet
46 } 80 }
47} 81}
48 82
49class FAMLoader extends MetamodelLoader{ 83class FAMLoader extends MetamodelLoader {
50 84
51 new(ReasonerWorkspace workspace) { 85 new(ReasonerWorkspace workspace) {
52 super(workspace) 86 super(workspace)
53 } 87 }
54 88
55 override loadMetamodel() { 89 override loadMetamodel() {
56 val package = FunctionalArchitecturePackage.eINSTANCE 90 val package = FunctionalarchitecturePackage.eINSTANCE
57 val List<EClass> classes = package.EClassifiers.filter(EClass).toList 91 val List<EClass> classes = package.EClassifiers.filter(EClass).toList
58 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList 92 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList
59 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList 93 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList
60 val List<EReference> references = classes.map[EReferences].flatten.toList 94 val List<EReference> references = classes.map[EReferences].flatten.filter [ reference |
95 !#{"model", "type"}.contains(reference.name)
96 ].toList
61 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList 97 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList
62 return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes) 98 return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)
63 } 99 }
64 100
65 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) { 101 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {
66 return descriptor.classes.filterByNames([it.name],#["FunctionalElement"]) 102 return descriptor.classes.filterByNames([it.name], #["FunctionalElement"])
67 } 103 }
104
68 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) { 105 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {
69 return descriptor.references.filterByNames([it.name],#["subElements"]) 106 return descriptor.references.filterByNames([it.name], #["subElements"])
70 } 107 }
71 108
72 override loadQueries(EcoreMetamodelDescriptor metamodel) { 109 override loadQueries(EcoreMetamodelDescriptor metamodel) {
73 val i = Pattern.instance 110 val i = FamPatterns.instance
74 val patterns = i.specifications.toList 111 val patterns = i.specifications.toList
75 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet 112 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet
76 val derivedFeatures = new LinkedHashMap 113 val derivedFeatures = new LinkedHashMap
77 derivedFeatures.put(i.type,metamodel.attributes.filter[it.name == "type"].head) 114// derivedFeatures.put(Type.instance,metamodel.attributes.filter[it.name == "type"].head)
78 derivedFeatures.put(i.model,metamodel.references.filter[it.name == "model"].head) 115// derivedFeatures.put(Model.instance,metamodel.references.filter[it.name == "model"].head)
79 val res = new ViatraQuerySetDescriptor( 116 val res = new ViatraQuerySetDescriptor(
80 patterns, 117 patterns,
81 wfPatterns, 118 wfPatterns,
@@ -83,65 +120,75 @@ class FAMLoader extends MetamodelLoader{
83 ) 120 )
84 return res 121 return res
85 } 122 }
123
86 override loadPartialModel() { 124 override loadPartialModel() {
87 this.workspace.readModel(EObject,"FAM.xmi").eResource.allContents.toList 125 this.workspace.readModel(EObject, "FAM.xmi").eResource.allContents.toList
88 } 126 }
89 127
90 override additionalConstraints() { #[] } 128 override additionalConstraints() { #[] }
91} 129}
92 130
93class YakinduLoader extends MetamodelLoader{ 131class YakinduLoader extends MetamodelLoader {
94 132
95 private var useSynchronization = true; 133 var useSynchronization = true;
96 private var useComplexStates = false; 134 var useComplexStates = false;
97 public static val patternsWithSynchronization = #[ 135 public static val patternsWithSynchronization = #["synchHasNoOutgoing", "synchHasNoIncoming",
98 "synchHasNoOutgoing", "synchHasNoIncoming", "SynchronizedIncomingInSameRegion", "notSynchronizingStates", 136 "SynchronizedIncomingInSameRegion", "SynchronizedIncomingInSameRegionHelper1",
99 "hasMultipleOutgoingTrainsition", "hasMultipleIncomingTrainsition", "SynchronizedRegionsAreNotSiblings", 137 "SynchronizedIncomingInSameRegionHelper2", "notSynchronizingStates", "hasMultipleOutgoingTrainsition",
100 "SynchronizedRegionDoesNotHaveMultipleRegions", "synchThree", "twoSynch","noSynch2","synch","noSynch4","noSynch3","noSynch"] 138 "hasMultipleIncomingTrainsition", "SynchronizedRegionsAreNotSiblings",
101 public static val patternsWithComplexStates =#["outgoingFromExit","outgoingFromFinal","choiceHasNoOutgoing","choiceHasNoIncoming"] 139 "SynchronizedRegionsAreNotSiblingsHelper1", "SynchronizedRegionsAreNotSiblingsHelper2",
140 "SynchronizedRegionDoesNotHaveMultipleRegions", "synchThree", "twoSynch", "noSynch2", "synch", "noSynch4",
141 "noSynch3", "noSynch"]
142 public static val patternsWithComplexStates = #["outgoingFromExit", "outgoingFromFinal", "choiceHasNoOutgoing",
143 "choiceHasNoIncoming"]
144
145 val boolean satisfiable
146
102 new(ReasonerWorkspace workspace) { 147 new(ReasonerWorkspace workspace) {
148 this(workspace, true)
149 }
150
151 new(ReasonerWorkspace workspace, boolean satisfiable) {
103 super(workspace) 152 super(workspace)
104 YakindummPackage.eINSTANCE.eClass 153 this.satisfiable = satisfiable
105 } 154 }
106 155
107 public def setUseSynchronization(boolean useSynchronization) { 156 def setUseSynchronization(boolean useSynchronization) {
108 this.useSynchronization = useSynchronization 157 this.useSynchronization = useSynchronization
109 } 158 }
110 public def setUseComplexStates(boolean useComplexStates) { 159
160 def setUseComplexStates(boolean useComplexStates) {
111 this.useComplexStates = useComplexStates 161 this.useComplexStates = useComplexStates
112 } 162 }
113 163
114 override loadMetamodel() { 164 override loadMetamodel() {
115 val useSynchInThisLoad = this.useSynchronization 165 val useSynchInThisLoad = this.useSynchronization
116 val useComplexStates = this.useComplexStates 166 val useComplexStates = this.useComplexStates
117 167
118 val package = YakindummPackage.eINSTANCE 168 val package = YakindummPackage.eINSTANCE
119 val List<EClass> classes = package.EClassifiers.filter(EClass) 169 val List<EClass> classes = package.EClassifiers.filter(EClass).filter [
120 .filter[useSynchInThisLoad || (it.name != "Synchronization")] 170 useSynchInThisLoad || (it.name != "Synchronization")
121 .filter[useComplexStates || (it.name != "Choice" && it.name != "Exit" && it.name != "FinalState")] 171 ].filter[useComplexStates || (it.name != "Choice" && it.name != "Exit" && it.name != "FinalState")].toList
122 .toList
123 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList 172 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList
124 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList 173 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList
125 val List<EReference> references = classes.map[EReferences].flatten.toList 174 val List<EReference> references = classes.map[EReferences].flatten.toList
126 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList 175 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList
127 176
128 return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes) 177 return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)
129 } 178 }
179
130 override loadQueries(EcoreMetamodelDescriptor metamodel) { 180 override loadQueries(EcoreMetamodelDescriptor metamodel) {
131 val useSynchInThisLoad = this.useSynchronization 181 val useSynchInThisLoad = this.useSynchronization
132 182
133 val i = Patterns.instance 183 val i = Patterns.instance
134 val patterns = i.specifications 184 val patterns = i.specifications.filter [ spec |
135 .filter[spec | 185 useSynchInThisLoad || !patternsWithSynchronization.exists[spec.fullyQualifiedName.endsWith(it)]
136 useSynchInThisLoad || 186 ].filter [ spec |
137 !patternsWithSynchronization.exists[spec.fullyQualifiedName.endsWith(it)] 187 useComplexStates || !patternsWithComplexStates.exists[spec.fullyQualifiedName.endsWith(it)]
138 ] 188 ].filter [
139 .filter[spec | 189 !satisfiable || !it.simpleName.startsWith(UNSAT_PREFIX)
140 useComplexStates || 190 ].toList
141 !patternsWithComplexStates.exists[spec.fullyQualifiedName.endsWith(it)] 191 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet
142 ]
143 .toList
144 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name== "Constraint"]].toSet
145 val derivedFeatures = new LinkedHashMap 192 val derivedFeatures = new LinkedHashMap
146 val res = new ViatraQuerySetDescriptor( 193 val res = new ViatraQuerySetDescriptor(
147 patterns, 194 patterns,
@@ -150,53 +197,85 @@ class YakinduLoader extends MetamodelLoader{
150 ) 197 )
151 return res 198 return res
152 } 199 }
200
153 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) { 201 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {
154 descriptor.classes.filterByNames([it.name],#["Vertex","Transition","Synchronization"]) 202 descriptor.classes.filterByNames([it.name], #["Vertex", "Transition", "Synchronization"])
155 } 203 }
156 204
157 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) { 205 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {
158 descriptor.references.filterByNames([it.name],#["source","target"]) 206 descriptor.references.filterByNames([it.name], #["source", "target"])
159 } 207 }
160 208
161 override loadPartialModel() { 209 override loadPartialModel() {
162 this.workspace.readModel(EObject,"Yakindu.xmi").eResource.allContents.toList 210 this.workspace.readModel(EObject, "Yakindu.xmi").eResource.allContents.toList
211 }
212
213 override additionalConstraints() {
214 // #[[method|new SGraphInconsistencyDetector(method)]]
215 emptyList
216 }
217
218 override getTypeQuantiles() {
219 #{
220 "Choice" -> new TypeQuantiles(0.118279569892473, 0.154020979020979),
221 "Entry" -> new TypeQuantiles(0.0283018867924528, 0.0620167525773196),
222 "Exit" -> new TypeQuantiles(0, 0),
223 "FinalState" -> new TypeQuantiles(0, 0),
224 "Region" -> new TypeQuantiles(0.0294117647058824, 0.0633258678611422),
225 "State" -> new TypeQuantiles(0.132023636740618, 0.175925925925926),
226// "Statechart" -> new TypeQuantiles(0.00961538461538462, 0.010752688172043),
227 "Transition" -> new TypeQuantiles(0.581632653061224, 0.645161290322581)
228 }
163 } 229 }
164 230
165 override additionalConstraints() { //#[] 231 override getUnsatTypeQuantiles() {
166 #[[method | new SGraphInconsistencyDetector(method)]] 232 #{
233 "Choice" -> new TypeQuantiles(0.118279569892473, 0.154020979020979),
234 "Entry" -> new TypeQuantiles(0.2, 0.4),
235 "Exit" -> new TypeQuantiles(0, 0),
236 "FinalState" -> new TypeQuantiles(0, 0),
237 "Region" -> new TypeQuantiles(0.0294117647058824, 0.0633258678611422),
238 "State" -> new TypeQuantiles(0.132023636740618, 0.175925925925926),
239// "Statechart" -> new TypeQuantiles(0.00961538461538462, 0.010752688172043),
240 "Transition" -> new TypeQuantiles(0.581632653061224, 0.645161290322581)
241 }
242 }
243
244 override getHints(Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) {
245 #[new SGraphHint(ecore2Logic, trace)]
167 } 246 }
168} 247}
169 248
170class FileSystemLoader extends MetamodelLoader{ 249class FileSystemLoader extends MetamodelLoader {
171 250
172 new(ReasonerWorkspace workspace) { 251 new(ReasonerWorkspace workspace) {
173 super(workspace) 252 super(workspace)
174 } 253 }
175 254
176 override loadMetamodel() { 255 override loadMetamodel() {
177 val package = FilesystemPackage.eINSTANCE 256 val package = FilesystemPackage.eINSTANCE
178 val List<EClass> classes = package.EClassifiers.filter(EClass).toList 257 val List<EClass> classes = package.EClassifiers.filter(EClass).toList
179 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList 258 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList
180 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList 259 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList
181 val List<EReference> references = classes.map[EReferences].flatten.toList 260 val List<EReference> references = classes.map[EReferences].flatten.filter[name != "live"].toList
182 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList 261 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList
183 return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes) 262 return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)
184 } 263 }
185 264
186 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) { 265 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {
187 return null 266 return null
188 } 267 }
189 268
190 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) { 269 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {
191 null 270 null
192 } 271 }
193 272
194 override loadQueries(EcoreMetamodelDescriptor metamodel) { 273 override loadQueries(EcoreMetamodelDescriptor metamodel) {
195 val patternGroup = FileSystem.instance 274 val patternGroup = FileSystem.instance
196 val patterns = patternGroup.specifications.toList 275 val patterns = patternGroup.specifications.toList
197 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet 276 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet
198 val derivedFeatures = new HashMap 277 val derivedFeatures = new HashMap
199 derivedFeatures.put(patternGroup.live,metamodel.references.filter[it.name == "live"].head) 278// derivedFeatures.put(patternGroup.live,metamodel.references.filter[it.name == "live"].head)
200 return new ViatraQuerySetDescriptor( 279 return new ViatraQuerySetDescriptor(
201 patterns, 280 patterns,
202 wfPatterns, 281 wfPatterns,
@@ -204,45 +283,69 @@ class FileSystemLoader extends MetamodelLoader{
204 ) 283 )
205 284
206 } 285 }
207 286
208 override loadPartialModel() { 287 override loadPartialModel() {
209 this.workspace.readModel(EObject,"fs.xmi").eResource.allContents.toList 288 this.workspace.readModel(EObject, "fs.xmi").eResource.allContents.toList
210 } 289 }
211 290
212 override additionalConstraints() { 291 override additionalConstraints() {
213 #[[method | new FileSystemInconsistencyDetector(method)]] 292 // #[[method|new FileSystemInconsistencyDetector(method)]]
293 emptyList
294 }
295
296 override getTypeQuantiles() {
297 #{
298 "Filesystem" -> new TypeQuantiles(0, 0.05),
299 "Dir" -> new TypeQuantiles(0.15, 0.3),
300 "File" -> new TypeQuantiles(0.25, 0.85)
301 }
214 } 302 }
215
216} 303}
217 304
218class EcoreLoader extends MetamodelLoader { 305class EcoreLoader extends MetamodelLoader {
219 306 val boolean satisfiable
307
220 new(ReasonerWorkspace workspace) { 308 new(ReasonerWorkspace workspace) {
309 this(workspace, true)
310 }
311
312 new(ReasonerWorkspace workspace, boolean satisfiable) {
221 super(workspace) 313 super(workspace)
314 this.satisfiable = satisfiable
222 } 315 }
223 316
224 override loadMetamodel() { 317 override loadMetamodel() {
225 val package = EcorePackage.eINSTANCE 318 val package = EcorePackage.eINSTANCE
226 val List<EClass> classes = package.EClassifiers.filter(EClass).filter[it.name!="EFactory"].toList 319 val List<EClass> classes = package.EClassifiers.filter(EClass).filter [
320 it.name != "EFactory" && it.name != "EObject" && it.name != "EResource"
321 ].toList
227 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList 322 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList
228 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList 323 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList
229 val List<EReference> references = classes.map[EReferences].flatten.filter[it.name!="eFactoryInstance"].filter[!it.derived].toList 324 val List<EReference> references = classes.map[EReferences].flatten.filter [
230 val List<EAttribute> attributes = #[] //classes.map[EAttributes].flatten.toList 325 it.name != "eFactoryInstance" && it.name != "contents" && it.name != "references" &&
231 return new EcoreMetamodelDescriptor(classes,#{},false,enums,literals,references,attributes) 326 it.name != "eGenericType" && it.name != "eGenericSuperTypes"
327 ].filter[!it.derived].toList
328 val List<EAttribute> attributes = #[] // classes.map[EAttributes].flatten.toList
329 return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)
232 } 330 }
233 331
234 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) { 332 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {
235 return null 333 return null
236 } 334 }
237 335
238 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) { 336 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {
239 null 337 null
240 } 338 }
241 339
242 override loadQueries(EcoreMetamodelDescriptor metamodel) { 340 override loadQueries(EcoreMetamodelDescriptor metamodel) {
243 val patternGroup = Ecore.instance 341 val patternGroup = Ecore.instance
244 val patterns = patternGroup.specifications.toList 342 val patterns = patternGroup.specifications.toList
245 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet 343 val allWfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet
344 val wfPatterns = if (satisfiable) {
345 allWfPatterns.filter[!it.simpleName.startsWith(UNSAT_PREFIX)].toSet
346 } else {
347 allWfPatterns
348 }
246 val derivedFeatures = new HashMap 349 val derivedFeatures = new HashMap
247 return new ViatraQuerySetDescriptor( 350 return new ViatraQuerySetDescriptor(
248 patterns, 351 patterns,
@@ -251,13 +354,111 @@ class EcoreLoader extends MetamodelLoader {
251 ) 354 )
252 355
253 } 356 }
254 357
255 override loadPartialModel() { 358 override loadPartialModel() {
256 this.workspace.readModel(EObject,"ecore.xmi").eResource.allContents.toList 359 this.workspace.readModel(EObject, "ecore.xmi").eResource.allContents.toList
257 } 360 }
258 361
259 override additionalConstraints() { 362 override additionalConstraints() {
260 #[] 363 #[]
261 } 364 }
262 365
263} \ No newline at end of file 366 override getTypeQuantiles() {
367 #{
368 "EAnnotation" -> new TypeQuantiles(0, 0),
369 "EAttribute" -> new TypeQuantiles(0.14, 0.300943396226415),
370 "EClass" -> new TypeQuantiles(0.224014336917563, 0.372881355932203),
371 "EDataType" -> new TypeQuantiles(0, 0),
372 "EEnum" -> new TypeQuantiles(0, 0.0275208638045255),
373 "EEnumLiteral" -> new TypeQuantiles(0, 0.105204907665065),
374 "EGenericType" -> new TypeQuantiles(0, 0),
375 "EOperation" -> new TypeQuantiles(0, 0),
376 "EPackage" -> new TypeQuantiles(0.0119047619047619, 0.0192307692307692),
377 "EParameter" -> new TypeQuantiles(0, 0),
378 "EReference" -> new TypeQuantiles(0.217599234815878, 0.406779661016949),
379 "EStringToStringMapEntry" -> new TypeQuantiles(0, 0),
380 "ETypeParameter" -> new TypeQuantiles(0, 0)
381 }
382 }
383
384}
385
386class SatelliteLoader extends MetamodelLoader {
387 val boolean satisfiable
388
389 new(ReasonerWorkspace workspace) {
390 this(workspace, true)
391 }
392
393 new(ReasonerWorkspace workspace, boolean satisfiable) {
394 super(workspace)
395 this.satisfiable = satisfiable
396 }
397
398 override loadMetamodel() {
399 val package = SatellitePackage.eINSTANCE
400 val List<EClass> classes = package.EClassifiers.filter(EClass).toList
401 val List<EEnum> enums = package.EClassifiers.filter(EEnum).toList
402 val List<EEnumLiteral> literals = enums.map[ELiterals].flatten.toList
403 val List<EReference> references = classes.map[EReferences].flatten.toList
404 val List<EAttribute> attributes = classes.map[EAttributes].flatten.toList
405 return new EcoreMetamodelDescriptor(classes, #{}, false, enums, literals, references, attributes)
406 }
407
408 override getRelevantTypes(EcoreMetamodelDescriptor descriptor) {
409 null
410 }
411
412 override getRelevantReferences(EcoreMetamodelDescriptor descriptor) {
413 null
414 }
415
416 override loadQueries(EcoreMetamodelDescriptor metamodel) {
417 val i = SatelliteQueriesAll.instance
418 val patterns = i.specifications.filter [
419 !satisfiable || !it.simpleName.startsWith(UNSAT_PREFIX)
420 ].toList
421 val wfPatterns = patterns.filter[it.allAnnotations.exists[it.name == "Constraint"]].toSet
422 val derivedFeatures = new LinkedHashMap
423 val res = new ViatraQuerySetDescriptor(
424 patterns,
425 wfPatterns,
426 derivedFeatures
427 )
428 return res
429 }
430
431 override loadPartialModel() {
432 this.workspace.readModel(EObject, "satellite.xmi").eResource.allContents.toList
433 }
434
435 override additionalConstraints() { #[] }
436
437 override getHints(Ecore2Logic ecore2Logic, Ecore2Logic_Trace trace) {
438 #[new SatelliteHint(ecore2Logic, trace)]
439 }
440
441 override getTypeQuantiles() {
442 #{
443 "CubeSat3U" -> new TypeQuantiles(0.1, 0.25),
444 "CubeSat6U" -> new TypeQuantiles(0, 0.25),
445 "SmallSat" -> new TypeQuantiles(0, 0.15),
446 "UHFCommSubsystem" -> new TypeQuantiles(0.08, 0.25),
447 "XCommSubsystem" -> new TypeQuantiles(0.08, 0.25),
448 "KaCommSubsystem" -> new TypeQuantiles(0, 0.1),
449 "InterferometryPayload" -> new TypeQuantiles(0.15, 0.25)
450 }
451 }
452
453 override getUnsatTypeQuantiles() {
454 #{
455 "CubeSat3U" -> new TypeQuantiles(0.1, 0.25),
456 "CubeSat6U" -> new TypeQuantiles(0.1, 0.25),
457 "SmallSat" -> new TypeQuantiles(0.1, 0.25),
458 "UHFCommSubsystem" -> new TypeQuantiles(0.08, 0.1),
459 "XCommSubsystem" -> new TypeQuantiles(0, 0.1),
460 "KaCommSubsystem" -> new TypeQuantiles(0, 0.05),
461 "InterferometryPayload" -> new TypeQuantiles(0.15, 0.25)
462 }
463 }
464}
generated by cgit v1.2.3-54-g00ecf (git 2.45.1) at 2024-05-29 19:00:25 +0000