1 files changed, 67 insertions, 4 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 7dc21410..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,13 +1,25 @@
 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) {

+

+        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

@@ -17,10 +29,61 @@ class GoalConstraintProvider {
                                 val query = queries.existingMultiplicityQuery

                                 val containment = constraint.containment

                                 val lowerBound = constraint.lowerBound

-                                res += new MultiplicityGoalConstraintCalculator(targetRelationName, query, containment, 1, 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

+        }

+}