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
|
package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
import java.util.ArrayList
import java.util.HashMap
import java.util.LinkedList
import java.util.List
import java.util.Map
class GoalConstraintProvider {
def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
val objectCosts = if (calculateObjectCost) {
calculateMissingObjectCost(p)
} else {
emptyMap
}
val res = new ArrayList()
for (entry : patterns.multiplicityConstraintQueries.entrySet) {
val constraint = entry.key
if (constraint.constrainsUnfinished) {
val queries = entry.value
val targetRelationName = constraint.relation.name
val query = queries.existingMultiplicityQuery
val containment = constraint.containment
val lowerBound = constraint.lowerBound
val cost = objectCosts.getOrDefault(constraint.relation, 1)
res += new MultiplicityGoalConstraintCalculator(
targetRelationName,
query,
containment,
lowerBound,
cost
)
}
}
return res
}
private def calculateMissingObjectCost(LogicProblem p) {
val containments = p.containmentHierarchies.head.containmentRelations
val containment2Lower = containments.toInvertedMap [ containment |
val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head
if (lower !== null) {
lower.lower
} else {
0
}
]
val types = p.types
val Map<Type, List<? extends Pair<Type, Integer>>> type2NewCost = new HashMap
for (type : types) {
val allSupertypes = (#[type] + type.supertypes).toSet
val allOutgoingContainments = containments.filter [
allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)
]
val list = new LinkedList
for (outgoingContainment : allOutgoingContainments) {
val value = containment2Lower.get(outgoingContainment)
if (value > 0) {
list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred -> value)
}
}
type2NewCost.put(type, list)
}
val res = new HashMap
for (containment : containments) {
val key = containment
val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)
// println('''«key.name» --> «value» new''')
res.put(key, value)
}
return res
}
private def int count(Type t, Map<Type, List<? extends Pair<Type, Integer>>> containments) {
val list = containments.get(t)
var r = 1
for (element : list) {
r += element.value * element.key.count(containments)
}
return r
}
}
|
