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