removed every occurence of check expressions

7 files changed, 56 insertions, 43 deletions

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
index 6435806d..05ce4f6e 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/MultiplicityGoalConstraintCalculator.xtend
@@ -10,13 +10,15 @@ class MultiplicityGoalConstraintCalculator {
         val String targetRelationName;

         val IQuerySpecification<?> querySpecification;

         var ViatraQueryMatcher<?> matcher;

+        val int minValue

         val boolean containment

         val int cost

                 

-        public new(String targetRelationName, IQuerySpecification<?> querySpecification, boolean containment, int cost) {

+        public new(String targetRelationName, IQuerySpecification<?> querySpecification, int minValue, boolean containment, int cost) {

                 this.targetRelationName = targetRelationName

                 this.querySpecification = querySpecification

                 this.matcher = null

+                this.minValue = minValue

                 this.containment = containment

                 this.cost = cost

         }

@@ -25,6 +27,7 @@ class MultiplicityGoalConstraintCalculator {
                 this.targetRelationName = other.targetRelationName

                 this.querySpecification = other.querySpecification

                 this.matcher = null

+                this.minValue = other.minValue

                 this.containment = other.containment

                 this.cost = other.cost

         }

@@ -47,13 +50,17 @@ class MultiplicityGoalConstraintCalculator {
                 val allMatches = this.matcher.allMatches

                 for(match : allMatches) {

                         

-                        val missingMultiplicity = match.get(4) as Integer

-                        res += missingMultiplicity

+                        val existingMultiplicity = match.get(4) as Integer

+                        if(existingMultiplicity < this.minValue) {

+                                val missingMultiplicity = this.minValue-existingMultiplicity

+                                res += missingMultiplicity

+                        }

 //                      if(missingMultiplicity!=0) {

 //                              println(targetRelationName+ " missing multiplicity: "+missingMultiplicity)

 //                      }

                 }

-                //println(targetRelationName+ " all missing multiplicities: "+res)

+//              if(res>0)

+//              println(targetRelationName+ " all missing multiplicities: "+res + "*"+cost+"="+res*cost)

                 return res*cost

         }

 }
\ 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/patterns/PConstraintTransformer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
index a4dcefbf..dd5cade1 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PConstraintTransformer.xtend
@@ -196,7 +196,9 @@ class PConstraintTransformer {
         def hasValue(PVariable v, String target, Modality m, List<VariableMapping> variableMapping) {

                 val typeReference = variableMapping.filter[it.sourcePVariable === v].head.targetLogicVariable.range as PrimitiveTypeReference

                 if(m.isMay) {

-                        '''PrimitiveElement.valueSet(«v.canonizeName»,«v.valueSetted»); «hasValueExpressionByRef(typeReference,v,v.valueVariable)» check(!«v.valueSetted»||«v.valueVariable»==«target»));'''

+                        '''PrimitiveElement.valueSet(«v.canonizeName»,«v.valueSetted»); «hasValueExpressionByRef(typeReference,v,v.valueVariable)»

+«««                  check(!«v.valueSetted»||«v.valueVariable»==«target»));

+'''

                 } else { // Must or current

                         '''PrimitiveElement.valueSet(«v.canonizeName»,true);«hasValueExpressionByRef(typeReference,v,target)»'''

                 }

@@ -233,13 +235,13 @@ class PConstraintTransformer {
                                         «FOR variable: e.affectedVariables»

                                                 PrimitiveElement.valueSet(«variable.canonizeName»,«variable.valueSetted»); «hasValueExpression(variableMapping,variable,variable.valueVariable)»

                                         «ENDFOR»

-                                        check(

-                                                «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»

+«««                                  check(

+«««                                          «FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»

 «««                                          «IF variable2Type.values.filter(RealTypeReference).empty»

 «««                                          ||

 «««                                          («expressionGenerator.translateExpression(expression,e.affectedVariables.toInvertedMap[valueVariable],variable2Type)»)

 «««                                          «ENDIF»

-                                        );

+«««                                  );

                                 '''

                         } else { // Must or Current

                                 return '''

@@ -263,7 +265,7 @@ class PConstraintTransformer {
                         «FOR variable: e.affectedVariables»

                                 PrimitiveElement.valueSet(«variable.canonizeName»,«variable.valueSetted»); «hasValueExpression(variableMapping,variable,variable.valueVariable)»

                         «ENDFOR»

-                        check(«FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»);

+«««                  check(«FOR variable: e.affectedVariables SEPARATOR " || "»!«variable.valueSetted»«ENDFOR»);

                 '''

         }

         

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
index cfea499b..f3de4ccc 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
@@ -27,8 +27,8 @@ import java.util.HashMap
 @Data class GeneratedPatterns {

         public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries

         public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries

-        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedContainmentMulticiplicityQueries

-        public Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedNonContainmentMulticiplicityQueries

+        public Map<Relation,  Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> unfinishedContainmentMulticiplicityQueries

+        public Map<Relation,  Pair<IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>,Integer>> unfinishedNonContainmentMulticiplicityQueries

         public Map<ObjectCreationPrecondition,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineObjectQueries

         public Map<? extends Type,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries

         public Map<Pair<RelationDeclaration, Relation>,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refinerelationQueries

@@ -93,11 +93,13 @@ class PatternProvider {
                 val unfinishedNonContainmentMultiplicities = new HashMap

                 for(entry : unfinishedMultiplicities.entrySet) {

                         val relation = entry.key

-                        val value = entry.value.lookup(queries)

+                        val name = entry.value.key

+                        val amount = entry.value.value

+                        val query = name.lookup(queries)

                         if(problem.containmentHierarchies.head.containmentRelations.contains(relation)) {

-                                unfinishedContainmentMultiplicities.put(relation,value)

+                                unfinishedContainmentMultiplicities.put(relation,query->amount)

                         } else {

-                                unfinishedNonContainmentMultiplicities.put(relation,value)

+                                unfinishedNonContainmentMultiplicities.put(relation,query->amount)

                         }

                 }

 //              val Map<Relation,  IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
index f384cd50..cef707c5 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
@@ -90,13 +90,13 @@ class RelationDeclarationIndexer {
                                 // There are "numberOfExistingReferences" currently existing instances of the reference from the source,

                                 // the upper bound of the multiplicity should be considered.

                                 numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»

-                                check(numberOfExistingReferences < «upperMultiplicities.get(relation)»);

+                                numberOfExistingReferences != «upperMultiplicities.get(relation)»;

                         «ENDIF»

                         «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»

                                 // There are "numberOfExistingReferences" currently existing instances of the reference to the target,

                                 // the upper bound of the opposite reference multiplicity should be considered.

                                 numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»

-                                check(numberOfExistingOppositeReferences < «upperMultiplicities.get(inverseRelations.get(relation))»);

+                                numberOfExistingOppositeReferences != «upperMultiplicities.get(inverseRelations.get(relation))»;

                         «ENDIF»

                         «IF containments.contains(relation)»

                                 // The reference is containment, then a new reference cannot be create if:

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
index ad1c9033..1df402fa 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
@@ -46,14 +46,14 @@ class UnfinishedIndexer {
                 val lowerMultiplicities = base.lowerMultiplicities(problem)

                 return '''

                 «FOR lowerMultiplicity : lowerMultiplicities»

-                        pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) {

+                        pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,numberOfExistingReferences) {

                                 find interpretation(problem,interpretation);

                                 PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);

                                 PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»");

                                 «base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")»

                                 numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)»

-                                check(numberOfExistingReferences < «lowerMultiplicity.lower»);

-                                missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);

+«««                          numberOfExistingReferences < «lowerMultiplicity.lower»;

+«««                          missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);

                         }

                 «ENDFOR»

                 '''

@@ -61,8 +61,8 @@ class UnfinishedIndexer {
         def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 

                 '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''

         

-        def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)

-                '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''

+        //def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)

+        //      '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''

         

         def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {

                 val parameters = lowerMultiplicityAssertion.relation.parameters

@@ -78,7 +78,7 @@ class UnfinishedIndexer {
                 val lowerMultiplicities = base.lowerMultiplicities(problem)

                 val map = new LinkedHashMap

                 for(lowerMultiplicity : lowerMultiplicities) {

-                        map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity))

+                        map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity)->lowerMultiplicity.lower)

                 }

                 return map

         }

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 87f7e339..0e8d341a 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
@@ -19,38 +19,40 @@ import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*

 

 class GoalConstraintProvider {

-        val calculateObjectCost = true

+        val calculateObjectCost = false

         

         def public getUnfinishedMultiplicityQueries(LogicProblem p, GeneratedPatterns patterns) {

                 val res = new ArrayList()

                 

-                res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)

+                res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)

                 if(calculateObjectCost) {

-                        val middingObjectCost = calculateMissingObjectCost(p)

-                        res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)

+                        val missingObjectCost = calculateMissingObjectCost(p)

+                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true,missingObjectCost)

                 } else {

-                        res.addAll(patterns.unfinishedNonContainmentMulticiplicityQueries,false)

+                        res.addAll(patterns.unfinishedContainmentMulticiplicityQueries,true)

                 }

                 return res

         }

         

-        def addAll(ArrayList<MultiplicityGoalConstraintCalculator> res, Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries, boolean containment) {

+        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

-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,1);

+                        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, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries,

+                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

-                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,containment,multiplicityQuery.key.lookup(cost))

+                        val query = multiplicityQuery.value.key

+                        val minValue = multiplicityQuery.value.value

+                        res += new MultiplicityGoalConstraintCalculator(targetRelationName,query,minValue,containment,multiplicityQuery.key.lookup(cost))

                 }

         }

         

@@ -80,7 +82,7 @@ class GoalConstraintProvider {
                 for(containment : containments) {

                         val key = containment

                         val value = (containment.parameters.get(1) as ComplexTypeReference).referred.count(type2NewCost)

-                        //println('''«key.name» --> «value» new''')

+//                      println('''«key.name» --> «value» new''')

                         res.put(key,value)

                 }

                 return res

diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
index 16438a5a..23ea118b 100644
--- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/rules/RefinementRuleProvider.xtend
@@ -413,9 +413,6 @@ class RefinementRuleProvider {
                         newElement.name = '''new «interpretation.newElements.size»'''

                 }

                 

-                // Existence

-                interpretation.newElements+=newElement

-                

                 // Types

                 typeInterpretation.elements += newElement

                 if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

@@ -431,6 +428,9 @@ class RefinementRuleProvider {
                 // Scope propagation

                 scopePropagator.propagateAdditionToType(typeInterpretation)

                 

+                // Existence

+                interpretation.newElements+=newElement

+                

                 // Do recursive object creation

                 for(newConstructor : recursiceObjectCreations) {

                         createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator)

@@ -454,9 +454,6 @@ class RefinementRuleProvider {
                         newElement.name = '''new «interpretation.newElements.size»'''

                 }

                 

-                // Existence

-                interpretation.newElements+=newElement

-                

                 // Types

                 typeInterpretation.elements += newElement

                 if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

@@ -469,6 +466,9 @@ class RefinementRuleProvider {
                 // Scope propagation

                 scopePropagator.propagateAdditionToType(typeInterpretation)

                 

+                // Existence

+                interpretation.newElements+=newElement

+                

                 // Do recursive object creation

                 for(newConstructor : recursiceObjectCreations) {

                         createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator)

@@ -490,9 +490,6 @@ class RefinementRuleProvider {
                         newElement.name = '''new «interpretation.newElements.size»'''

                 }

                 

-                // Existence

-                interpretation.newElements+=newElement

-                

                 // Types

                 typeInterpretation.elements += newElement

                 if(typeInterpretation instanceof PartialComplexTypeInterpretation) {

@@ -502,6 +499,9 @@ class RefinementRuleProvider {
                 // Scope propagation

                 scopePropagator.propagateAdditionToType(typeInterpretation)

                 

+                // Existence

+                interpretation.newElements+=newElement

+                

                 // Do recursive object creation

                 for(newConstructor : recursiceObjectCreations) {

                         createObjectAction(nameNewElement,newConstructor,newElement,scopePropagator)