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