1 files changed, 12 insertions, 84 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
index e03a8c35..238ade5b 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
@@ -1,98 +1,26 @@
 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.Relation
-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.MultiplicityGoalConstraintCalculator
+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
-import org.eclipse.viatra.query.runtime.api.IPatternMatch
-import org.eclipse.viatra.query.runtime.api.IQuerySpecification
-import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
-import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
 class GoalConstraintProvider {
        
-        def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
+        def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns) {
                val res = new ArrayList()
-                
+                for (entry : patterns.multiplicityConstraintQueries.entrySet) {
-                res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)
+                        val constraint = entry.key
-                if(calculateObjectCost) {
+                        if (constraint.constrainsUnfinished) {
-                        val missingObjectCost = calculateMissingObjectCost(p)
+                                val queries = entry.value
-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost)
+                                val targetRelationName = constraint.relation.name
-                } else {
+                                val query = queries.unfinishedMultiplicityQuery
-                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)
+                                val minValue = constraint.lowerBound
-                }
+                                val containment = constraint.containment
-                return res
+                                res += new MultiplicityGoalConstraintCalculator(targetRelationName, query, minValue, containment, 1)
-        }
-        
-        def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries, boolean containment) {
-                for(multiplicityQuery : queries.entrySet) {
-                        val targetRelationName = multiplicityQuery.key.name
-                        val query = multiplicityQuery.value.key
-                        val minValue = multiplicityQuery.value.value
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,1);
-                }
-        }
-        def addAll(
-                ArrayList<MultiplicityGoalConstraintCalculator> res,
-                Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries,
-                boolean containment,
-                Map<Relation, Integer> cost
-        ) {
-                for(multiplicityQuery : queries.entrySet) {
-                        val targetRelationName = multiplicityQuery.key.name
-                        val query = multiplicityQuery.value.key
-                        val minValue = multiplicityQuery.value.value
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost))
-                }
-        }
-        
-        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
-        }
 }
 \ No newline at end of file

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend index e03a8c35..238ade5b 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/GoalConstraintProvider.xtend
@@ -1,98 +1,26 @@
1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules	1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
2		2
3	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
4	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
5	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
6	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
7	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem	3	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
8	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator	4	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
9	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns	5	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
10	import java.util.ArrayList	6	import java.util.ArrayList
11	import java.util.HashMap
12	import java.util.LinkedList
13	import java.util.List
14	import java.util.Map
15	import org.eclipse.viatra.query.runtime.api.IPatternMatch
16	import org.eclipse.viatra.query.runtime.api.IQuerySpecification
17	import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
18
19	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
20		7
21	class GoalConstraintProvider {	8	class GoalConstraintProvider {
22		9
23	def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {	10	def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns) {
24	val res = new ArrayList()	11	val res = new ArrayList()
25		12	for (entry : patterns.multiplicityConstraintQueries.entrySet) {
26	res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)	13	val constraint = entry.key
27	if(calculateObjectCost) {	14	if (constraint.constrainsUnfinished) {
28	val missingObjectCost = calculateMissingObjectCost(p)	15	val queries = entry.value
29	res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost)	16	val targetRelationName = constraint.relation.name
30	} else {	17	val query = queries.unfinishedMultiplicityQuery
31	res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)	18	val minValue = constraint.lowerBound
32	}	19	val containment = constraint.containment
33	return res	20	res += new MultiplicityGoalConstraintCalculator(targetRelationName, query, minValue, containment, 1)
34	}
35
36	def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries, boolean containment) {
37	for(multiplicityQuery : queries.entrySet) {
38	val targetRelationName = multiplicityQuery.key.name
39	val query = multiplicityQuery.value.key
40	val minValue = multiplicityQuery.value.value
41	res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,1);
42	}
43	}
44	def addAll(
45	ArrayList<MultiplicityGoalConstraintCalculator> res,
46	Map<Relation, Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> queries,
47	boolean containment,
48	Map<Relation, Integer> cost
49	) {
50	for(multiplicityQuery : queries.entrySet) {
51	val targetRelationName = multiplicityQuery.key.name
52	val query = multiplicityQuery.value.key
53	val minValue = multiplicityQuery.value.value
54	res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost))
55	}
56	}
57
58	def calculateMissingObjectCost(LogicProblem p) {
59	val containments = p.containmentHierarchies.head.containmentRelations
60	val containment2Lower = containments.toInvertedMap[containment \|
61	val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head
62	if(lower !== null) { lower.lower }
63	else { 0 }
64	]
65	val types = p.types
66	val Map<Type,List<? extends Pair<Type,Integer>>> type2NewCost = new HashMap
67	for(type:types) {
68	val allSupertypes = (#[type] + type.supertypes).toSet
69	val allOutgoingContainments = containments.filter[allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)]
70	val list = new LinkedList
71	for(outgoingContainment : allOutgoingContainments) {
72	val value = containment2Lower.get(outgoingContainment)
73	if(value>0) {
74	list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred
75	-> value)
76	}
77	}	21	}
78	type2NewCost.put(type, list)
79	}
80	val res = new HashMap
81	for(containment : containments) {
82	val key = containment
83	val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)
84	// println('''«key.name» --> «value» new''')
85	res.put(key,value)
86	}	22	}
87	return res	23	return res
88	}	24	}
89		25
90	private def int count(Type t, Map<Type,List<? extends Pair<Type,Integer>>> containments) {
91	val list = containments.get(t)
92	var r = 1
93	for(element : list) {
94	r += element.value * element.key.count(containments)
95	}
96	return r
97	}
98	} \ No newline at end of file	26	} \ No newline at end of file