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 | 391 |
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 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.run | 1 | package hu.bme.mit.inf.dslreasoner.run |
2 | 2 | ||
3 | import hu.bme.mit.inf.dslreasomer.domains.transima.fam.FunctionalArchitecture.FunctionalArchitecturePackage | 3 | import functionalarchitecture.FunctionalarchitecturePackage |
4 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Ecore | ||
4 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.FileSystem | 5 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.FileSystem |
5 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FilesystemPackage | 6 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Filesystem.FilesystemPackage |
6 | import hu.bme.mit.inf.dslreasoner.domains.transima.fam.patterns.Pattern | 7 | import hu.bme.mit.inf.dslreasoner.domains.satellite.queries.internal.SatelliteQueriesAll |
8 | import hu.bme.mit.inf.dslreasoner.domains.transima.fam.FamPatterns | ||
7 | 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 | ||
8 | import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor | 12 | import hu.bme.mit.inf.dslreasoner.ecore2logic.EcoreMetamodelDescriptor |
9 | import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns | 13 | import hu.bme.mit.inf.dslreasoner.partialsnapshot_mavo.yakindu.Patterns |
10 | import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor | 14 | import hu.bme.mit.inf.dslreasoner.viatra2logic.ViatraQuerySetDescriptor |
11 | 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 | ||
12 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethodBasedGlobalConstraint | 17 | import hu.bme.mit.inf.dslreasoner.viatrasolver.reasoner.ModelGenerationMethodBasedGlobalConstraint |
13 | import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace | 18 | import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace |
14 | import java.util.Collection | 19 | import java.util.Collection |
20 | import java.util.HashMap | ||
15 | import java.util.LinkedHashMap | 21 | import java.util.LinkedHashMap |
16 | import java.util.List | 22 | import java.util.List |
23 | import java.util.Map | ||
17 | import java.util.Set | 24 | import java.util.Set |
18 | import org.eclipse.emf.ecore.EAttribute | 25 | import org.eclipse.emf.ecore.EAttribute |
19 | import org.eclipse.emf.ecore.EClass | 26 | import org.eclipse.emf.ecore.EClass |
@@ -21,61 +28,91 @@ import org.eclipse.emf.ecore.EEnum | |||
21 | import org.eclipse.emf.ecore.EEnumLiteral | 28 | import org.eclipse.emf.ecore.EEnumLiteral |
22 | import org.eclipse.emf.ecore.EObject | 29 | import org.eclipse.emf.ecore.EObject |
23 | import org.eclipse.emf.ecore.EReference | 30 | import org.eclipse.emf.ecore.EReference |
24 | import org.eclipse.xtext.xbase.lib.Functions.Function1 | ||
25 | import java.util.HashMap | ||
26 | import org.eclipse.emf.ecore.EcorePackage | 31 | import org.eclipse.emf.ecore.EcorePackage |
27 | import hu.bme.mit.inf.dslreasoner.domains.alloyexamples.Ecore | 32 | import org.eclipse.xtend.lib.annotations.Data |
33 | import org.eclipse.xtext.xbase.lib.Functions.Function1 | ||
34 | import satellite.SatellitePackage | ||
35 | |||
36 | @Data | ||
37 | class TypeQuantiles { | ||
38 | double low | ||
39 | double high | ||
40 | } | ||
28 | 41 | ||
29 | abstract class MetamodelLoader { | 42 | abstract 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 | ||
49 | class FAMLoader extends MetamodelLoader{ | 83 | class 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 | ||
93 | class YakinduLoader extends MetamodelLoader{ | 131 | class 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 | ||
170 | class FileSystemLoader extends MetamodelLoader{ | 249 | class 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 | ||
218 | class EcoreLoader extends MetamodelLoader { | 305 | class 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 | |||
386 | class 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 | } | ||