diff options
Diffstat (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend')
-rw-r--r-- | Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend | 209 |
1 files changed, 209 insertions, 0 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend new file mode 100644 index 00000000..8b0f8f85 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend | |||
@@ -0,0 +1,209 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
9 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics | ||
10 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns | ||
11 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.ObjectCreationPrecondition | ||
12 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation | ||
13 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation | ||
14 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation | ||
15 | import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory | ||
16 | import java.util.LinkedHashMap | ||
17 | import org.eclipse.viatra.query.runtime.api.GenericPatternMatch | ||
18 | import org.eclipse.viatra.query.runtime.api.IQuerySpecification | ||
19 | import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher | ||
20 | import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRule | ||
21 | import org.eclipse.viatra.transformation.runtime.emf.rules.batch.BatchTransformationRuleFactory | ||
22 | |||
23 | class RefinementRuleProvider { | ||
24 | private extension BatchTransformationRuleFactory factory = new BatchTransformationRuleFactory | ||
25 | private extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE | ||
26 | private extension LogiclanguageFactory factory3 = LogiclanguageFactory.eINSTANCE | ||
27 | |||
28 | def canonizeName(String name) { | ||
29 | return name.replace(' ','_') | ||
30 | } | ||
31 | |||
32 | def LinkedHashMap<ObjectCreationPrecondition, BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>>> | ||
33 | createObjectRefinementRules( | ||
34 | GeneratedPatterns patterns, | ||
35 | boolean nameNewElement, | ||
36 | ModelGenerationStatistics statistics | ||
37 | ) | ||
38 | { | ||
39 | val res = new LinkedHashMap | ||
40 | for(LHSEntry: patterns.refineObjectQueries.entrySet) { | ||
41 | val containmentRelation = LHSEntry.key.containmentRelation | ||
42 | val inverseRelation = LHSEntry.key.inverseContainment | ||
43 | val type = LHSEntry.key.newType | ||
44 | val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> | ||
45 | val rule = createObjectCreationRule(containmentRelation,inverseRelation,type,lhs,nameNewElement,statistics) | ||
46 | res.put(LHSEntry.key,rule) | ||
47 | } | ||
48 | return res | ||
49 | } | ||
50 | |||
51 | def private createObjectCreationRule( | ||
52 | Relation containmentRelation, | ||
53 | Relation inverseRelation, | ||
54 | Type type, | ||
55 | IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, | ||
56 | boolean nameNewElement, | ||
57 | ModelGenerationStatistics statistics) | ||
58 | { | ||
59 | val name = '''addObject_«type.name.canonizeName»« | ||
60 | IF containmentRelation!=null»_by_«containmentRelation.name.canonizeName»«ENDIF»''' | ||
61 | val ruleBuilder = factory.createRule | ||
62 | .name(name) | ||
63 | .precondition(lhs) | ||
64 | if(containmentRelation != null) { | ||
65 | if(inverseRelation!= null) { | ||
66 | ruleBuilder.action[match | | ||
67 | //println(name) | ||
68 | val startTime = System.nanoTime | ||
69 | //val problem = match.get(0) as LogicProblem | ||
70 | val interpretation = match.get(1) as PartialInterpretation | ||
71 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
72 | val inverseRelationInterpretation = match.get(3) as PartialRelationInterpretation | ||
73 | val typeInterpretation = match.get(4) as PartialTypeInterpratation | ||
74 | val container = match.get(5) as DefinedElement | ||
75 | |||
76 | val newElement = createDefinedElement | ||
77 | if(nameNewElement) { | ||
78 | newElement.name = '''new «interpretation.newElements.size»''' | ||
79 | } | ||
80 | |||
81 | // Existence | ||
82 | interpretation.newElements+=newElement | ||
83 | interpretation.maxNewElements=interpretation.maxNewElements-1 | ||
84 | if(interpretation.minNewElements > 0) { | ||
85 | interpretation.minNewElements=interpretation.minNewElements-1 | ||
86 | } | ||
87 | |||
88 | // Types | ||
89 | typeInterpretation.elements += newElement | ||
90 | typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement] | ||
91 | // ContainmentRelation | ||
92 | val newLink1 = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement] | ||
93 | relationInterpretation.relationlinks+=newLink1 | ||
94 | // Inverse Containment | ||
95 | val newLink2 = factory2.createBinaryElementRelationLink => [it.param1 = newElement it.param2 = container] | ||
96 | inverseRelationInterpretation.relationlinks+=newLink2 | ||
97 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
98 | ] | ||
99 | } else { | ||
100 | ruleBuilder.action[match | | ||
101 | //println(name) | ||
102 | val startTime = System.nanoTime | ||
103 | //val problem = match.get(0) as LogicProblem | ||
104 | val interpretation = match.get(1) as PartialInterpretation | ||
105 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
106 | val typeInterpretation = match.get(3) as PartialTypeInterpratation | ||
107 | val container = match.get(4) as DefinedElement | ||
108 | |||
109 | val newElement = createDefinedElement | ||
110 | if(nameNewElement) { | ||
111 | newElement.name = '''new «interpretation.newElements.size»''' | ||
112 | } | ||
113 | |||
114 | // Existence | ||
115 | interpretation.newElements+=newElement | ||
116 | interpretation.maxNewElements=interpretation.maxNewElements-1 | ||
117 | if(interpretation.minNewElements > 0) { | ||
118 | interpretation.minNewElements=interpretation.minNewElements-1 | ||
119 | } | ||
120 | |||
121 | // Types | ||
122 | typeInterpretation.elements += newElement | ||
123 | typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement] | ||
124 | // ContainmentRelation | ||
125 | val newLink = factory2.createBinaryElementRelationLink => [it.param1 = container it.param2 = newElement] | ||
126 | relationInterpretation.relationlinks+=newLink | ||
127 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
128 | ] | ||
129 | } | ||
130 | } else { | ||
131 | ruleBuilder.action[match | | ||
132 | //println(name) | ||
133 | val startTime = System.nanoTime | ||
134 | //val problem = match.get(0) as LogicProblem | ||
135 | val interpretation = match.get(1) as PartialInterpretation | ||
136 | val typeInterpretation = match.get(2) as PartialTypeInterpratation | ||
137 | |||
138 | val newElement = createDefinedElement //=> [it.name = null] | ||
139 | if(nameNewElement) { | ||
140 | newElement.name = '''new «interpretation.newElements.size»''' | ||
141 | } | ||
142 | // Existence | ||
143 | interpretation.newElements+=newElement | ||
144 | interpretation.maxNewElements=interpretation.maxNewElements-1 | ||
145 | if(interpretation.minNewElements > 0) { | ||
146 | interpretation.minNewElements=interpretation.minNewElements-1 | ||
147 | } | ||
148 | // Types | ||
149 | typeInterpretation.elements += newElement | ||
150 | typeInterpretation.supertypeInterpretation.forEach[it.elements += newElement] | ||
151 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
152 | ] | ||
153 | } | ||
154 | return ruleBuilder.build | ||
155 | } | ||
156 | |||
157 | def createRelationRefinementRules(GeneratedPatterns patterns, ModelGenerationStatistics statistics) { | ||
158 | val res = new LinkedHashMap | ||
159 | for(LHSEntry: patterns.refinerelationQueries.entrySet) { | ||
160 | val declaration = LHSEntry.key.key | ||
161 | val inverseReference = LHSEntry.key.value | ||
162 | val lhs = LHSEntry.value as IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> | ||
163 | val rule = createRelationRefinementRule(declaration,inverseReference,lhs,statistics) | ||
164 | res.put(LHSEntry.key,rule) | ||
165 | } | ||
166 | return res | ||
167 | } | ||
168 | |||
169 | def private BatchTransformationRule<GenericPatternMatch, ViatraQueryMatcher<GenericPatternMatch>> | ||
170 | createRelationRefinementRule(RelationDeclaration declaration, Relation inverseRelation, IQuerySpecification<ViatraQueryMatcher<GenericPatternMatch>> lhs, ModelGenerationStatistics statistics) | ||
171 | { | ||
172 | val name = '''addRelation_«declaration.name.canonizeName»«IF inverseRelation != null»_and_«inverseRelation.name.canonizeName»«ENDIF»''' | ||
173 | val ruleBuilder = factory.createRule | ||
174 | .name(name) | ||
175 | .precondition(lhs) | ||
176 | if (inverseRelation == null) { | ||
177 | ruleBuilder.action [ match | | ||
178 | val startTime = System.nanoTime | ||
179 | //println(name) | ||
180 | // val problem = match.get(0) as LogicProblem | ||
181 | // val interpretation = match.get(1) as PartialInterpretation | ||
182 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
183 | val src = match.get(3) as DefinedElement | ||
184 | val trg = match.get(4) as DefinedElement | ||
185 | val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg] | ||
186 | relationInterpretation.relationlinks += link | ||
187 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
188 | ] | ||
189 | } else { | ||
190 | ruleBuilder.action [ match | | ||
191 | val startTime = System.nanoTime | ||
192 | //println(name) | ||
193 | // val problem = match.get(0) as LogicProblem | ||
194 | // val interpretation = match.get(1) as PartialInterpretation | ||
195 | val relationInterpretation = match.get(2) as PartialRelationInterpretation | ||
196 | val inverseInterpretation = match.get(3) as PartialRelationInterpretation | ||
197 | val src = match.get(4) as DefinedElement | ||
198 | val trg = match.get(5) as DefinedElement | ||
199 | val link = createBinaryElementRelationLink => [it.param1 = src it.param2 = trg] | ||
200 | relationInterpretation.relationlinks += link | ||
201 | val inverseLink = createBinaryElementRelationLink => [it.param1 = trg it.param2 = src] | ||
202 | inverseInterpretation.relationlinks += inverseLink | ||
203 | statistics.addExecutionTime(System.nanoTime-startTime) | ||
204 | ] | ||
205 | } | ||
206 | |||
207 | return ruleBuilder.build | ||
208 | } | ||
209 | } | ||