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