1 files changed, 175 insertions, 56 deletions
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 1df402fa..a8a07756 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
@@ -1,85 +1,204 @@
 package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
-import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
 import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
-import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationMultiplicityConstraint
+import java.util.LinkedHashMap
+import java.util.List
 import java.util.Map
 import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
+import org.eclipse.xtend.lib.annotations.Data
 import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
-import java.util.LinkedHashMap
-import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+@Data
-import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+class UnifinishedMultiplicityQueryNames {
+        val String unfinishedMultiplicityQueryName
+        val String unrepairableMultiplicityQueryName
+        val String remainingInverseMultiplicityQueryName
+        val String remainingContentsQueryName
+}
 class UnfinishedIndexer {
        val PatternGenerator base
-        
+        val boolean indexUpperMultiplicities
-        new(PatternGenerator patternGenerator) {
+        new(PatternGenerator patternGenerator, boolean indexUpperMultiplicities) {
                this.base = patternGenerator
+                this.indexUpperMultiplicities = indexUpperMultiplicities
        }
-        
-        def generateUnfinishedWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {
+        def generateUnfinishedWfQueries(LogicProblem problem, Map<String, PQuery> fqn2PQuery) {
                val wfQueries = base.wfQueries(problem)
                '''
-                «FOR wfQuery: wfQueries»
+                        «FOR wfQuery : wfQueries»
-                        pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
+                                pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
-                                «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
+                                        «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
-                        {
+                                {
-                                «base.relationDefinitionIndexer.referPattern(
+                                        «base.relationDefinitionIndexer.referPattern(
                                        wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),
                                        wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],
                                        Modality.CURRENT,
                                        true,false)»
-                        }
+                                }
-                «ENDFOR»
+                        «ENDFOR»
                '''
        }
        def getUnfinishedWFQueryNames(LogicProblem problem) {
                val wfQueries = base.wfQueries(problem)
                val map = new LinkedHashMap
-                for(wfQuery : wfQueries) {
+                for (wfQuery : wfQueries) {
-                        map.put(wfQuery.target,'''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')
+                        map.put(wfQuery.target, '''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')
                }
                return map
        }
-        def generateUnfinishedMultiplicityQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {
-                val lowerMultiplicities = base.lowerMultiplicities(problem)
+        def generateUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints,
-                return '''
+                Map<String, PQuery> fqn2PQuery) '''
-                «FOR lowerMultiplicity : lowerMultiplicities»
+                «FOR constraint : constraints»
-                        pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,numberOfExistingReferences) {
+                        «IF constraint.constrainsUnfinished»
-                                find interpretation(problem,interpretation);
+                                private pattern «unfinishedMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, missingMultiplicity:java Integer) {
-                                PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
+                                        find interpretation(problem,interpretation);
-                                PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»");
+                                        find mustExist(problem,interpretation,object);
-                                «base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")»
+                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
-                                numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)»
+                                        numberOfExistingReferences == count «base.referRelation(constraint.relation,"object","_",Modality.MUST,fqn2PQuery)»
-«««                          numberOfExistingReferences < «lowerMultiplicity.lower»;
+                                        check(numberOfExistingReferences < «constraint.lowerBound»);
-«««                          missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);
+                                        missingMultiplicity == eval(«constraint.lowerBound»-numberOfExistingReferences);
-                        }
+                                }
+                                
+                                pattern «unfinishedMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, missingMultiplicity:java Integer) {
+                                        find interpretation(problem,interpretation);
+                                        missingMultiplicity == sum find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
+                                }
+                        «ENDIF»
+                        
+                        «IF indexUpperMultiplicities»
+                                «IF constraint.constrainsUnrepairable || constraint.constrainsRemainingInverse»
+                                        private pattern «repairMatchName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, source:DefinedElement, target:DefinedElement) {
+                                                «IF base.isRepresentative(constraint.relation, constraint.inverseRelation) && constraint.relation instanceof RelationDeclaration»
+                                                        «base.relationRefinementGenerator.referRefinementQuery(constraint.relation as RelationDeclaration, constraint.inverseRelation, "_", "_", "source", "target")»
+                                                «ELSE»
+                                                        «IF base.isRepresentative(constraint.inverseRelation, constraint.relation) && constraint.inverseRelation instanceof RelationDeclaration»
+                                                                «base.relationRefinementGenerator.referRefinementQuery(constraint.inverseRelation as RelationDeclaration, constraint.relation, "_", "_", "target", "source")»
+                                                        «ELSE»
+                                                                find interpretation(problem,interpretation);
+                                                                find mustExist(problem,interpretation,source);
+                                                                «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"source")»
+                                                                find mustExist(problem,interpretation,target);
+                                                                «base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"target")»
+                                                                neg «base.referRelation(constraint.relation,"source","target",Modality.MUST,fqn2PQuery)»
+                                                                «base.referRelation(constraint.relation,"source","target",Modality.MAY,fqn2PQuery)»
+                                                        «ENDIF»
+                                                «ENDIF»
+                                        }
+                                «ENDIF»
+                                
+                                «IF constraint.constrainsUnrepairable»
+                                        private pattern «unrepairableMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, unrepairableMultiplicity:java Integer) {
+                                                find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, object, missingMultiplicity);
+                                                numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, object, _);
+                                                check(numberOfRepairMatches < missingMultiplicity);
+                                                unrepairableMultiplicity == eval(missingMultiplicity-numberOfRepairMatches);
+                                        }
+                                        
+                                        private pattern «unrepairableMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, unrepairableMultiplicity:java Integer) {
+                                                find interpretation(problem,interpretation);
+                                                unrepairableMultiplicity == max find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
+                                        } or {
+                                                find interpretation(problem,interpretation);
+                                                neg find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, _);
+                                                unrepairableMultiplicity == 0;
+                                        }
+                                «ENDIF»
+                                
+                                «IF constraint.constrainsRemainingInverse»
+                                        private pattern «remainingMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {
+                                                find interpretation(problem,interpretation);
+                                                find mustExist(problem,interpretation,object);
+                                                «base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"object")»
+                                                numberOfExistingReferences == count «base.referRelation(constraint.relation,"_","object",Modality.MUST,fqn2PQuery)»
+                                                check(numberOfExistingReferences < «constraint.inverseUpperBound»);
+                                                numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, _, object);
+                                                remainingMultiplicity == eval(Math.min(«constraint.inverseUpperBound»-numberOfExistingReferences, numberOfRepairMatches));
+                                        }
+                                        
+                                        pattern «remainingMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
+                                                find interpretation(problem,interpretation);
+                                                remainingMultiplicity == sum find «remainingMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
+                                        }
+                                «ENDIF»
+                                
+                                «IF constraint.constrainsRemainingContents»
+                                        «IF constraint.upperBoundFinite»
+                                                private pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {
+                                                        find interpretation(problem,interpretation);
+                                                        find mustExist(problem,interpretation,object);
+                                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
+                                                        numberOfExistingReferences == count «base.referRelation(constraint.relation,"object","_",Modality.MUST,fqn2PQuery)»
+                                                        check(numberOfExistingReferences < «constraint.upperBound»);
+                                                        remainingMultiplicity == eval(«constraint.upperBound»-numberOfExistingReferences);
+                                                }
+                                                
+                                                pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
+                                                        find interpretation(problem,interpretation);
+                                                        remainingMultiplicity == sum find «remainingContentsName(constraint)»_helper(problem, interpretation, _, #_);
+                                                }
+                                        «ELSE»
+                                                pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation) {
+                                                        find interpretation(problem,interpretation);
+                                                        find mustExist(problem,interpretation,object);
+                                                        «base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
+                                                }
+                                                
+                                                pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
+                                                        find interpretation(problem,interpretation);
+                                                        find «remainingContentsName(constraint)»_helper(problem, interpretation);
+                                                        remainingMultiplicity == -1;
+                                                } or {
+                                                        find interpretation(problem,interpretation);
+                                                        neg find «remainingContentsName(constraint)»_helper(problem, interpretation);
+                                                        remainingMultiplicity == 0;
+                                                }
+                                        «ENDIF»
+                                «ENDIF»
+                        «ENDIF»
                «ENDFOR»
-                '''
+        '''
-        }
-        def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 
+        def String unfinishedMultiplicityName(
-                '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''
+                RelationMultiplicityConstraint constraint) '''unfinishedLowerMultiplicity_«base.canonizeName(constraint.relation.name)»'''
-        
-        //def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)
+        def String unrepairableMultiplicityName(
-        //      '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''
+                RelationMultiplicityConstraint constraint) '''unrepairableLowerMultiplicity_«base.canonizeName(constraint.relation.name)»'''
-        
-        def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {
+        private def String repairMatchName(
-                val parameters = lowerMultiplicityAssertion.relation.parameters
+                RelationMultiplicityConstraint constraint) '''repair_«base.canonizeName(constraint.relation.name)»'''
-                if(parameters.size == 2) {
-                        val firstParam = parameters.get(0)
+        def String remainingMultiplicityName(
-                        if(firstParam instanceof ComplexTypeReference) {
+                RelationMultiplicityConstraint constraint) '''remainingInverseUpperMultiplicity_«base.canonizeName(constraint.relation.name)»'''
-                                return firstParam.referred
-                        }
+        def String remainingContentsName(
-                }
+                RelationMultiplicityConstraint constraint) '''remainingContents_«base.canonizeName(constraint.relation.name)»'''
-        }
-        
+        def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {
-        def getUnfinishedMultiplicityQueries(LogicProblem problem) {
+                constraints.toInvertedMap [ constraint |
-                val lowerMultiplicities = base.lowerMultiplicities(problem)
+                        new UnifinishedMultiplicityQueryNames(
-                val map = new LinkedHashMap
+                                if(constraint.constrainsUnfinished) unfinishedMultiplicityName(constraint) else null,
-                for(lowerMultiplicity : lowerMultiplicities) {
+                                if (indexUpperMultiplicities && constraint.constrainsUnrepairable)
-                        map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity)->lowerMultiplicity.lower)
+                                        unrepairableMultiplicityName(constraint)
-                }
+                                else
-                return map
+                                        null,
+                                if (indexUpperMultiplicities && constraint.constrainsRemainingInverse)
+                                        remainingMultiplicityName(constraint)
+                                else
+                                        null,
+                                if (indexUpperMultiplicities && constraint.constrainsRemainingContents)
+                                        remainingContentsName(constraint)
+                                else
+                                        null
+                        )
+                ]
        }
 }

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 1df402fa..a8a07756 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
@@ -1,85 +1,204 @@
1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns	1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2		2
3	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion	3	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
4	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem	4	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
5	import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint	5	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
		6	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.cardinality.RelationMultiplicityConstraint
		7	import java.util.LinkedHashMap
		8	import java.util.List
6	import java.util.Map	9	import java.util.Map
7	import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery	10	import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
		11	import org.eclipse.xtend.lib.annotations.Data
8		12
9	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*	13	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
10	import java.util.LinkedHashMap	14
11	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality	15	@Data
12	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference	16	class UnifinishedMultiplicityQueryNames {
		17	val String unfinishedMultiplicityQueryName
		18	val String unrepairableMultiplicityQueryName
		19	val String remainingInverseMultiplicityQueryName
		20	val String remainingContentsQueryName
		21	}
13		22
14	class UnfinishedIndexer {	23	class UnfinishedIndexer {
15	val PatternGenerator base	24	val PatternGenerator base
16		25	val boolean indexUpperMultiplicities
17	new(PatternGenerator patternGenerator) {	26
		27	new(PatternGenerator patternGenerator, boolean indexUpperMultiplicities) {
18	this.base = patternGenerator	28	this.base = patternGenerator
		29	this.indexUpperMultiplicities = indexUpperMultiplicities
19	}	30	}
20		31
21	def generateUnfinishedWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {	32	def generateUnfinishedWfQueries(LogicProblem problem, Map<String, PQuery> fqn2PQuery) {
22	val wfQueries = base.wfQueries(problem)	33	val wfQueries = base.wfQueries(problem)
23	'''	34	'''
24	«FOR wfQuery: wfQueries»	35	«FOR wfQuery : wfQueries»
25	pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,	36	pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
26	«FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)	37	«FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
27	{	38	{
28	«base.relationDefinitionIndexer.referPattern(	39	«base.relationDefinitionIndexer.referPattern(
29	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),	40	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),
30	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],	41	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],
31	Modality.CURRENT,	42	Modality.CURRENT,
32	true,false)»	43	true,false)»
33	}	44	}
34	«ENDFOR»	45	«ENDFOR»
35	'''	46	'''
36	}	47	}
		48
37	def getUnfinishedWFQueryNames(LogicProblem problem) {	49	def getUnfinishedWFQueryNames(LogicProblem problem) {
38	val wfQueries = base.wfQueries(problem)	50	val wfQueries = base.wfQueries(problem)
39	val map = new LinkedHashMap	51	val map = new LinkedHashMap
40	for(wfQuery : wfQueries) {	52	for (wfQuery : wfQueries) {
41	map.put(wfQuery.target,'''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')	53	map.put(wfQuery.target, '''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')
42	}	54	}
43	return map	55	return map
44	}	56	}
45	def generateUnfinishedMultiplicityQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {	57
46	val lowerMultiplicities = base.lowerMultiplicities(problem)	58	def generateUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints,
47	return '''	59	Map<String, PQuery> fqn2PQuery) '''
48	«FOR lowerMultiplicity : lowerMultiplicities»	60	«FOR constraint : constraints»
49	pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,numberOfExistingReferences) {	61	«IF constraint.constrainsUnfinished»
50	find interpretation(problem,interpretation);	62	private pattern «unfinishedMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, missingMultiplicity:java Integer) {
51	PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);	63	find interpretation(problem,interpretation);
52	PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»");	64	find mustExist(problem,interpretation,object);
53	«base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")»	65	«base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
54	numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)»	66	numberOfExistingReferences == count «base.referRelation(constraint.relation,"object","_",Modality.MUST,fqn2PQuery)»
55	««« numberOfExistingReferences < «lowerMultiplicity.lower»;	67	check(numberOfExistingReferences < «constraint.lowerBound»);
56	««« missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);	68	missingMultiplicity == eval(«constraint.lowerBound»-numberOfExistingReferences);
57	}	69	}
		70
		71	pattern «unfinishedMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, missingMultiplicity:java Integer) {
		72	find interpretation(problem,interpretation);
		73	missingMultiplicity == sum find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
		74	}
		75	«ENDIF»
		76
		77	«IF indexUpperMultiplicities»
		78	«IF constraint.constrainsUnrepairable \|\| constraint.constrainsRemainingInverse»
		79	private pattern «repairMatchName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, source:DefinedElement, target:DefinedElement) {
		80	«IF base.isRepresentative(constraint.relation, constraint.inverseRelation) && constraint.relation instanceof RelationDeclaration»
		81	«base.relationRefinementGenerator.referRefinementQuery(constraint.relation as RelationDeclaration, constraint.inverseRelation, "_", "_", "source", "target")»
		82	«ELSE»
		83	«IF base.isRepresentative(constraint.inverseRelation, constraint.relation) && constraint.inverseRelation instanceof RelationDeclaration»
		84	«base.relationRefinementGenerator.referRefinementQuery(constraint.inverseRelation as RelationDeclaration, constraint.relation, "_", "_", "target", "source")»
		85	«ELSE»
		86	find interpretation(problem,interpretation);
		87	find mustExist(problem,interpretation,source);
		88	«base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"source")»
		89	find mustExist(problem,interpretation,target);
		90	«base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"target")»
		91	neg «base.referRelation(constraint.relation,"source","target",Modality.MUST,fqn2PQuery)»
		92	«base.referRelation(constraint.relation,"source","target",Modality.MAY,fqn2PQuery)»
		93	«ENDIF»
		94	«ENDIF»
		95	}
		96	«ENDIF»
		97
		98	«IF constraint.constrainsUnrepairable»
		99	private pattern «unrepairableMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, unrepairableMultiplicity:java Integer) {
		100	find «unfinishedMultiplicityName(constraint)»_helper(problem, interpretation, object, missingMultiplicity);
		101	numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, object, _);
		102	check(numberOfRepairMatches < missingMultiplicity);
		103	unrepairableMultiplicity == eval(missingMultiplicity-numberOfRepairMatches);
		104	}
		105
		106	private pattern «unrepairableMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, unrepairableMultiplicity:java Integer) {
		107	find interpretation(problem,interpretation);
		108	unrepairableMultiplicity == max find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
		109	} or {
		110	find interpretation(problem,interpretation);
		111	neg find «unrepairableMultiplicityName(constraint)»_helper(problem, interpretation, _, _);
		112	unrepairableMultiplicity == 0;
		113	}
		114	«ENDIF»
		115
		116	«IF constraint.constrainsRemainingInverse»
		117	private pattern «remainingMultiplicityName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {
		118	find interpretation(problem,interpretation);
		119	find mustExist(problem,interpretation,object);
		120	«base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"object")»
		121	numberOfExistingReferences == count «base.referRelation(constraint.relation,"_","object",Modality.MUST,fqn2PQuery)»
		122	check(numberOfExistingReferences < «constraint.inverseUpperBound»);
		123	numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, _, object);
		124	remainingMultiplicity == eval(Math.min(«constraint.inverseUpperBound»-numberOfExistingReferences, numberOfRepairMatches));
		125	}
		126
		127	pattern «remainingMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
		128	find interpretation(problem,interpretation);
		129	remainingMultiplicity == sum find «remainingMultiplicityName(constraint)»_helper(problem, interpretation, _, #_);
		130	}
		131	«ENDIF»
		132
		133	«IF constraint.constrainsRemainingContents»
		134	«IF constraint.upperBoundFinite»
		135	private pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, remainingMultiplicity:java Integer) {
		136	find interpretation(problem,interpretation);
		137	find mustExist(problem,interpretation,object);
		138	«base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
		139	numberOfExistingReferences == count «base.referRelation(constraint.relation,"object","_",Modality.MUST,fqn2PQuery)»
		140	check(numberOfExistingReferences < «constraint.upperBound»);
		141	remainingMultiplicity == eval(«constraint.upperBound»-numberOfExistingReferences);
		142	}
		143
		144	pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
		145	find interpretation(problem,interpretation);
		146	remainingMultiplicity == sum find «remainingContentsName(constraint)»_helper(problem, interpretation, _, #_);
		147	}
		148	«ELSE»
		149	pattern «remainingContentsName(constraint)»_helper(problem:LogicProblem, interpretation:PartialInterpretation) {
		150	find interpretation(problem,interpretation);
		151	find mustExist(problem,interpretation,object);
		152	«base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
		153	}
		154
		155	pattern «remainingContentsName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, remainingMultiplicity:java Integer) {
		156	find interpretation(problem,interpretation);
		157	find «remainingContentsName(constraint)»_helper(problem, interpretation);
		158	remainingMultiplicity == -1;
		159	} or {
		160	find interpretation(problem,interpretation);
		161	neg find «remainingContentsName(constraint)»_helper(problem, interpretation);
		162	remainingMultiplicity == 0;
		163	}
		164	«ENDIF»
		165	«ENDIF»
		166	«ENDIF»
58	«ENDFOR»	167	«ENDFOR»
59	'''	168	'''
60	}	169
61	def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion)	170	def String unfinishedMultiplicityName(
62	'''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''	171	RelationMultiplicityConstraint constraint) '''unfinishedLowerMultiplicity_«base.canonizeName(constraint.relation.name)»'''
63		172
64	//def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)	173	def String unrepairableMultiplicityName(
65	// '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''	174	RelationMultiplicityConstraint constraint) '''unrepairableLowerMultiplicity_«base.canonizeName(constraint.relation.name)»'''
66		175
67	def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {	176	private def String repairMatchName(
68	val parameters = lowerMultiplicityAssertion.relation.parameters	177	RelationMultiplicityConstraint constraint) '''repair_«base.canonizeName(constraint.relation.name)»'''
69	if(parameters.size == 2) {	178
70	val firstParam = parameters.get(0)	179	def String remainingMultiplicityName(
71	if(firstParam instanceof ComplexTypeReference) {	180	RelationMultiplicityConstraint constraint) '''remainingInverseUpperMultiplicity_«base.canonizeName(constraint.relation.name)»'''
72	return firstParam.referred	181
73	}	182	def String remainingContentsName(
74	}	183	RelationMultiplicityConstraint constraint) '''remainingContents_«base.canonizeName(constraint.relation.name)»'''
75	}	184
76		185	def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {
77	def getUnfinishedMultiplicityQueries(LogicProblem problem) {	186	constraints.toInvertedMap [ constraint \|
78	val lowerMultiplicities = base.lowerMultiplicities(problem)	187	new UnifinishedMultiplicityQueryNames(
79	val map = new LinkedHashMap	188	if(constraint.constrainsUnfinished) unfinishedMultiplicityName(constraint) else null,
80	for(lowerMultiplicity : lowerMultiplicities) {	189	if (indexUpperMultiplicities && constraint.constrainsUnrepairable)
81	map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity)->lowerMultiplicity.lower)	190	unrepairableMultiplicityName(constraint)
82	}	191	else
83	return map	192	null,
		193	if (indexUpperMultiplicities && constraint.constrainsRemainingInverse)
		194	remainingMultiplicityName(constraint)
		195	else
		196	null,
		197	if (indexUpperMultiplicities && constraint.constrainsRemainingContents)
		198	remainingContentsName(constraint)
		199	else
		200	null
		201	)
		202	]
84	}	203	}
85	}	204	}