1 files changed, 80 insertions, 9 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 e1be2742..732c135d 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,18 +1,89 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.rules
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator
+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 public getUnfinishedMultiplicityQueries(GeneratedPatterns patterns) {
-                val multiplicityQueries = patterns.unfinishedMulticiplicityQueries
+        def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
-                val res = new ArrayList(multiplicityQueries.size)
+                val objectCosts = if (calculateObjectCost) {
-                for(multiplicityQuery : multiplicityQueries.entrySet) {
+                                calculateMissingObjectCost(p)
-                        val targetRelationName = multiplicityQuery.key.name
+                        } else {
-                        val query = multiplicityQuery.value
+                                emptyMap
-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query);
+                        }
+                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
        }
-}
-\ No newline at end of file
+        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
+        }
+}

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 e1be2742..732c135d 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,18 +1,89 @@
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.viatrasolver.logic2viatra.MultiplicityGoalConstraintCalculator	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.Type
		6	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
		7	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.MultiplicityGoalConstraintCalculator
4	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns	8	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns.GeneratedPatterns
5	import java.util.ArrayList	9	import java.util.ArrayList
		10	import java.util.HashMap
		11	import java.util.LinkedList
		12	import java.util.List
		13	import java.util.Map
6		14
7	class GoalConstraintProvider {	15	class GoalConstraintProvider {
8	def public getUnfinishedMultiplicityQueries(GeneratedPatterns patterns) {	16
9	val multiplicityQueries = patterns.unfinishedMulticiplicityQueries	17	def getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns, boolean calculateObjectCost) {
10	val res = new ArrayList(multiplicityQueries.size)	18	val objectCosts = if (calculateObjectCost) {
11	for(multiplicityQuery : multiplicityQueries.entrySet) {	19	calculateMissingObjectCost(p)
12	val targetRelationName = multiplicityQuery.key.name	20	} else {
13	val query = multiplicityQuery.value	21	emptyMap
14	res += new MultiplicityGoalConstraintCalculator(targetRelationName,query);	22	}
		23	val res = new ArrayList()
		24	for (entry : patterns.multiplicityConstraintQueries.entrySet) {
		25	val constraint = entry.key
		26	if (constraint.constrainsUnfinished) {
		27	val queries = entry.value
		28	val targetRelationName = constraint.relation.name
		29	val query = queries.existingMultiplicityQuery
		30	val containment = constraint.containment
		31	val lowerBound = constraint.lowerBound
		32	val cost = objectCosts.getOrDefault(constraint.relation, 1)
		33	res += new MultiplicityGoalConstraintCalculator(
		34	targetRelationName,
		35	query,
		36	containment,
		37	lowerBound,
		38	cost
		39	)
		40	}
15	}	41	}
16	return res	42	return res
17	}	43	}
18	} \ No newline at end of file	44
		45	private def calculateMissingObjectCost(LogicProblem p) {
		46	val containments = p.containmentHierarchies.head.containmentRelations
		47	val containment2Lower = containments.toInvertedMap [ containment \|
		48	val lower = p.annotations.filter(LowerMultiplicityAssertion).filter[it.relation === containment].head
		49	if (lower !== null) {
		50	lower.lower
		51	} else {
		52	0
		53	}
		54	]
		55	val types = p.types
		56	val Map<Type, List<? extends Pair<Type, Integer>>> type2NewCost = new HashMap
		57	for (type : types) {
		58	val allSupertypes = (#[type] + type.supertypes).toSet
		59	val allOutgoingContainments = containments.filter [
		60	allSupertypes.contains((it.parameters.get(0) as ComplexTypeReference).referred)
		61	]
		62	val list = new LinkedList
		63	for (outgoingContainment : allOutgoingContainments) {
		64	val value = containment2Lower.get(outgoingContainment)
		65	if (value > 0) {
		66	list.add((outgoingContainment.parameters.get(1) as ComplexTypeReference).referred -> value)
		67	}
		68	}
		69	type2NewCost.put(type, list)
		70	}
		71	val res = new HashMap
		72	for (containment : containments) {
		73	val key = containment
		74	val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)
		75	// println('''«key.name» --> «value» new''')
		76	res.put(key, value)
		77	}
		78	return res
		79	}
		80
		81	private def int count(Type t, Map<Type, List<? extends Pair<Type, Integer>>> containments) {
		82	val list = containments.get(t)
		83	var r = 1
		84	for (element : list) {
		85	r += element.value * element.key.count(containments)
		86	}
		87	return r
		88	}
		89	}