diff options
Diffstat (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend')
-rw-r--r-- | Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend | 184 |
1 files changed, 14 insertions, 170 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend index 9723373f..338a9af2 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend | |||
@@ -5,38 +5,27 @@ import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | |||
5 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery | 5 | import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery |
6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality | 6 | import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality |
7 | import java.util.Map | 7 | import java.util.Map |
8 | import org.eclipse.emf.ecore.EAttribute | ||
9 | import org.eclipse.emf.ecore.EEnumLiteral | ||
10 | import org.eclipse.emf.ecore.EReference | ||
11 | import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey | ||
12 | import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey | ||
13 | import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey | ||
14 | import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint | ||
15 | import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable | 8 | import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable |
16 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality | ||
17 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter | ||
18 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality | ||
19 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall | ||
20 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure | 9 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure |
21 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue | 10 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PDisjunction |
22 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall | ||
23 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint | ||
24 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery | 11 | import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery |
25 | 12 | ||
26 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | 13 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* |
27 | import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.TypeFilterConstraint | ||
28 | 14 | ||
29 | class RelationDefinitionIndexer { | 15 | class RelationDefinitionIndexer { |
30 | val PatternGenerator base; | 16 | public val PatternGenerator base; |
17 | val PConstraintTransformer constraintTransformer; | ||
31 | 18 | ||
32 | new(PatternGenerator base) { | 19 | new(PatternGenerator base) { |
33 | this.base = base | 20 | this.base = base |
21 | this.constraintTransformer = new PConstraintTransformer(this); | ||
34 | } | 22 | } |
35 | 23 | ||
36 | public def generateRelationDefinitions( | 24 | def generateRelationDefinitions( |
37 | LogicProblem problem, | 25 | LogicProblem problem, |
38 | Iterable<RelationDefinition> relations, | 26 | Iterable<RelationDefinition> relations, |
39 | Map<String,PQuery> fqn2PQuery) { | 27 | Map<String,PQuery> fqn2PQuery) |
28 | { | ||
40 | val relation2PQuery = relations.toInvertedMap[ | 29 | val relation2PQuery = relations.toInvertedMap[ |
41 | annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery) | 30 | annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery) |
42 | ] | 31 | ] |
@@ -71,23 +60,24 @@ class RelationDefinitionIndexer { | |||
71 | ] | 60 | ] |
72 | } | 61 | } |
73 | 62 | ||
74 | private def relationDefinitionName(RelationDefinition relation, Modality modality) | 63 | def String relationDefinitionName(RelationDefinition relation, Modality modality) |
75 | '''«modality.name.toLowerCase»InRelation_«base.canonizeName(relation.name)»''' | 64 | '''«modality.name.toLowerCase»InRelation_«base.canonizeName(relation.name)»''' |
76 | 65 | ||
77 | private def canonizeName(PVariable v) { | 66 | def canonizeName(PVariable v) { |
78 | return '''«IF v.referringConstraints.size == 1»_«ENDIF»var_«v.name.replaceAll("\\W","")»''' | 67 | return '''«IF v.referringConstraints.size == 1»_«ENDIF»var_«v.name.replaceAll("\\W","")»''' |
79 | } | 68 | } |
80 | 69 | ||
81 | private def transformPattern(RelationDefinition relation, PQuery p, Modality modality) { | 70 | private def transformPattern(RelationDefinition relation, PQuery p, Modality modality) { |
82 | try { | 71 | try { |
72 | val bodies = (relation.annotations.filter(TransfomedViatraQuery).head.optimizedDisjunction as PDisjunction).bodies | ||
83 | return ''' | 73 | return ''' |
84 | private pattern «relationDefinitionName(relation,modality)»( | 74 | private pattern «relationDefinitionName(relation,modality)»( |
85 | problem:LogicProblem, interpretation:PartialInterpretation, | 75 | problem:LogicProblem, interpretation:PartialInterpretation, |
86 | «FOR param : p.parameters SEPARATOR ', '»var_«param.name»«ENDFOR») | 76 | «FOR param : p.parameters SEPARATOR ', '»var_«param.name»«ENDFOR») |
87 | «FOR body : p.disjunctBodies.bodies SEPARATOR "or"»{ | 77 | «FOR body : bodies SEPARATOR "or"»{ |
88 | find interpretation(problem,interpretation); | 78 | find interpretation(problem,interpretation); |
89 | «FOR constraint : body.constraints» | 79 | «FOR constraint : body.constraints» |
90 | «constraint.transformConstraint(modality)» | 80 | «this.constraintTransformer.transformConstraint(constraint,modality,relation.annotations.filter(TransfomedViatraQuery).head.variableTrace)» |
91 | «ENDFOR» | 81 | «ENDFOR» |
92 | }«ENDFOR» | 82 | }«ENDFOR» |
93 | ''' | 83 | ''' |
@@ -104,158 +94,12 @@ class RelationDefinitionIndexer { | |||
104 | ''' | 94 | ''' |
105 | } | 95 | } |
106 | 96 | ||
107 | private def toMustMay(Modality modality) { | 97 | def toMustMay(Modality modality) { |
108 | if(modality == Modality::MAY) return Modality::MAY | 98 | if(modality == Modality::MAY) return Modality::MAY |
109 | else return Modality::MUST | 99 | else return Modality::MUST |
110 | } | 100 | } |
111 | 101 | ||
112 | def public referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) ''' | 102 | def referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) ''' |
113 | «IF !positive»neg «ENDIF»find «IF transitive»twoParam_«ENDIF»«modality.name.toLowerCase»InRelation_pattern_«p.fullyQualifiedName.replace('.','_')»«IF transitive»+«ENDIF»(«IF !transitive»problem,interpretation,«ENDIF»«variables.join(',')»); | 103 | «IF !positive»neg «ENDIF»find «IF transitive»twoParam_«ENDIF»«modality.name.toLowerCase»InRelation_pattern_«p.fullyQualifiedName.replace('.','_')»«IF transitive»+«ENDIF»(«IF !transitive»problem,interpretation,«ENDIF»«variables.join(',')»); |
114 | ''' | 104 | ''' |
115 | |||
116 | private dispatch def transformConstraint(TypeConstraint constraint, Modality modality) { | ||
117 | val touple = constraint.variablesTuple | ||
118 | if(touple.size == 1) { | ||
119 | val inputKey = constraint.equivalentJudgement.inputKey | ||
120 | if(inputKey instanceof EClassTransitiveInstancesKey) { | ||
121 | return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay, | ||
122 | constraint.getVariableInTuple(0).canonizeName) | ||
123 | } else if(inputKey instanceof EDataTypeInSlotsKey){ | ||
124 | return '''// type constraint is enforced by construction''' | ||
125 | } | ||
126 | |||
127 | } else if(touple.size == 2){ | ||
128 | val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey | ||
129 | if(key instanceof EReference) { | ||
130 | return base.referRelationByName( | ||
131 | key, | ||
132 | constraint.getVariableInTuple(0).canonizeName, | ||
133 | constraint.getVariableInTuple(1).canonizeName, | ||
134 | modality.toMustMay) | ||
135 | } else if (key instanceof EAttribute) { | ||
136 | return base.referAttributeByName(key, | ||
137 | constraint.getVariableInTuple(0).canonizeName, | ||
138 | constraint.getVariableInTuple(1).canonizeName, | ||
139 | modality.toMustMay) | ||
140 | } else throw new UnsupportedOperationException('''unknown key: «key.class»''') | ||
141 | } else { | ||
142 | throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''') | ||
143 | } | ||
144 | } | ||
145 | private dispatch def transformConstraint(TypeFilterConstraint constraint, Modality modality) { | ||
146 | val touple = constraint.variablesTuple | ||
147 | if(touple.size == 1) { | ||
148 | val inputKey = constraint.equivalentJudgement.inputKey | ||
149 | if(inputKey instanceof EClassTransitiveInstancesKey) { | ||
150 | return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay, | ||
151 | (constraint.getVariablesTuple.get(0) as PVariable).canonizeName) | ||
152 | } else if(inputKey instanceof EDataTypeInSlotsKey){ | ||
153 | return '''// type constraint is enforced by construction''' | ||
154 | } | ||
155 | |||
156 | } else if(touple.size == 2){ | ||
157 | val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey | ||
158 | if(key instanceof EReference) { | ||
159 | return base.referRelationByName( | ||
160 | key, | ||
161 | (constraint.getVariablesTuple.get(0) as PVariable).canonizeName, | ||
162 | (constraint.getVariablesTuple.get(1) as PVariable).canonizeName, | ||
163 | modality.toMustMay) | ||
164 | } else if (key instanceof EAttribute) { | ||
165 | return base.referAttributeByName(key, | ||
166 | (constraint.getVariablesTuple.get(0) as PVariable).canonizeName, | ||
167 | (constraint.getVariablesTuple.get(1) as PVariable).canonizeName, | ||
168 | modality.toMustMay) | ||
169 | } else throw new UnsupportedOperationException('''unknown key: «key.class»''') | ||
170 | } else { | ||
171 | throw new UnsupportedOperationException('''Unsupported touple size: «touple.size»''') | ||
172 | } | ||
173 | } | ||
174 | |||
175 | private dispatch def transformConstraint(Equality equality, Modality modality) { | ||
176 | val a = equality.who | ||
177 | val b = equality.withWhom | ||
178 | transformEquality(modality.toMustMay, a, b) | ||
179 | } | ||
180 | |||
181 | private def CharSequence transformEquality(Modality modality, PVariable a, PVariable b) { | ||
182 | if(modality.isMustOrCurrent) '''find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);''' | ||
183 | else '''find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);''' | ||
184 | } | ||
185 | |||
186 | private dispatch def transformConstraint(Inequality inequality, Modality modality) { | ||
187 | val a = inequality.who | ||
188 | val b = inequality.withWhom | ||
189 | if(modality.isCurrent) { | ||
190 | return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);''' | ||
191 | } else if(modality.isMust) { | ||
192 | return '''neg find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);''' | ||
193 | } else { // modality.isMay | ||
194 | return '''neg find mustEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);''' | ||
195 | } | ||
196 | } | ||
197 | |||
198 | private dispatch def transformConstraint(NegativePatternCall pcall, Modality modality) { | ||
199 | val params = (0..<pcall.actualParametersTuple.size).map[index | | ||
200 | val variable = pcall.actualParametersTuple.get(index) as PVariable | ||
201 | return variable.canonizeName | ||
202 | ] | ||
203 | return referPattern(pcall.referredQuery,params,modality.dual,false,false) | ||
204 | } | ||
205 | |||
206 | private dispatch def transformConstraint(PositivePatternCall pcall, Modality modality) { | ||
207 | val params = (0..<pcall.variablesTuple.size).map[index | | ||
208 | val variable = pcall.variablesTuple.get(index) as PVariable | ||
209 | return variable.canonizeName | ||
210 | ] | ||
211 | return referPattern(pcall.referredQuery,params,modality,true,false) | ||
212 | } | ||
213 | private dispatch def transformConstraint(BinaryTransitiveClosure pcall, Modality modality) { | ||
214 | val params = (0..1).map[index | | ||
215 | val variable = pcall.getVariableInTuple(index) as PVariable | ||
216 | return variable.canonizeName | ||
217 | ] | ||
218 | return referPattern(pcall.referredQuery,params,modality,true,true) | ||
219 | } | ||
220 | private dispatch def transformConstraint(ExportedParameter e, Modality modality) { | ||
221 | return '''// «e.parameterName» is exported''' | ||
222 | } | ||
223 | private dispatch def transformConstraint(ConstantValue c, Modality modality) { | ||
224 | val target = c.supplierKey | ||
225 | |||
226 | var String targetString; | ||
227 | var String additionalDefinition; | ||
228 | if(target instanceof EEnumLiteral) { | ||
229 | targetString = '''const_«target.name»_«target.EEnum.name»''' | ||
230 | additionalDefinition = '''DefinedElement.name(«targetString»,"«target.name» «target.EEnum.name»"); //LogicProblem.elements(problem,«targetString»);''' | ||
231 | } else if(target instanceof Integer) { | ||
232 | targetString = '''const_«target»_Integer''' | ||
233 | additionalDefinition = '''IntegerElement.value(«targetString»,«target»);''' | ||
234 | } else if(target instanceof Boolean) { | ||
235 | targetString = '''const_«target»_Boolean''' | ||
236 | additionalDefinition = '''BooleanElement.value(«targetString»,«target»);''' | ||
237 | } else if(target instanceof String) { | ||
238 | targetString = '''const_«target»_String''' | ||
239 | additionalDefinition = '''StringElement.value(«targetString»,"«target»");''' | ||
240 | } else if(target instanceof Double) { | ||
241 | targetString = '''const_«target»_Number''' | ||
242 | additionalDefinition = '''RealElement.value(«targetString»,"«target»");''' | ||
243 | } else if(target instanceof Float) { | ||
244 | targetString = '''const_«target»_Number''' | ||
245 | additionalDefinition = '''RealElement.value(«targetString»,"«target»");''' | ||
246 | } else { | ||
247 | throw new UnsupportedOperationException('''Unknown constant type: «target.class»''') | ||
248 | } | ||
249 | |||
250 | val source = c.variablesTuple | ||
251 | var String sourceName | ||
252 | if(source.size == 1) | ||
253 | sourceName = (source.get(0) as PVariable).canonizeName | ||
254 | else throw new UnsupportedOperationException("unknown source") | ||
255 | return '''«sourceName» == «targetString»;«additionalDefinition»'''; | ||
256 | } | ||
257 | |||
258 | private dispatch def transformConstraint(PConstraint c, Modality modality) { | ||
259 | throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.name»"!''') | ||
260 | } | ||
261 | } \ No newline at end of file | 105 | } \ No newline at end of file |