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