1 files changed, 118 insertions, 54 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..65ad3d48 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,149 @@
 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 existingMultiplicityQueryName
+        val String existingInverseMultiplicityQueryName
+}
 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.shouldIndexExistingMultiplicites(indexUpperMultiplicities)»
-                                find interpretation(problem,interpretation);
+                                private pattern «existingMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer«IF constraint.shouldIndexRepairMultiplcities(indexUpperMultiplicities)», numberOfRepairMatches: java Integer«ENDIF») {
-                                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»);
+                                        «IF constraint.shouldIndexRepairMultiplcities(indexUpperMultiplicities)»
-                                missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);
+                                                numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, object, _);
-                        }
+                                        «ENDIF»
+                                }
+                        «ENDIF»
+                        
+                        «IF constraint.shouldIndexRepairMatches(indexUpperMultiplicities)»
+                                private pattern «repairMatchName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, source:DefinedElement, target:DefinedElement) {
+                                        «IF constraint.containment || constraint.container»
+                                                «repairMatchFallback(constraint, fqn2PQuery)»
+                                        «ELSEIF base.isRepresentative(constraint.relation, constraint.inverseRelation) && constraint.relation instanceof RelationDeclaration»
+                                                «base.relationRefinementGenerator.referRefinementQuery(constraint.relation as RelationDeclaration, constraint.inverseRelation, "_", "_", "source", "target")»
+                                        «ELSEIF base.isRepresentative(constraint.inverseRelation, constraint.relation) && constraint.inverseRelation instanceof RelationDeclaration»
+                                                «base.relationRefinementGenerator.referRefinementQuery(constraint.inverseRelation as RelationDeclaration, constraint.relation, "_", "_", "target", "source")»
+                                        «ELSE»
+                                                «repairMatchFallback(constraint, fqn2PQuery)»
+                                        «ENDIF»
+                                }
+                        «ENDIF»
+                        
+                        «IF constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)»
+                                private pattern «existingInverseMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer, numberOfRepairMatches: 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)»
+                                        numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, _, object);
+                                }
+                        «ENDIF»
                «ENDFOR»
-                '''
+        '''
+        private def repairMatchFallback(RelationMultiplicityConstraint constraint, Map<String, PQuery> fqn2PQuery) '''
+                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)»
+        '''
+        def String existingMultiplicityName(
+                RelationMultiplicityConstraint constraint) '''existingMultiplicity_«base.canonizeName(constraint.relation.name)»'''
+        def String existingInverseMultiplicityName(
+                RelationMultiplicityConstraint constraint) '''existingInverseMultiplicity_«base.canonizeName(constraint.relation.name)»'''
+        private def String repairMatchName(
+                RelationMultiplicityConstraint constraint) '''repair_«base.canonizeName(constraint.relation.name)»'''
+        def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {
+                constraints.toInvertedMap [ constraint |
+                        new UnifinishedMultiplicityQueryNames(
+                                if (constraint.shouldIndexExistingMultiplicites(indexUpperMultiplicities)) {
+                                        existingMultiplicityName(constraint)
+                                } else {
+                                        null
+                                },
+                                if (constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)) {
+                                        existingInverseMultiplicityName(constraint)
+                                } else {
+                                        null
+                                }
+                        )
+                ]
        }
-        def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion) 
-                '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''
+        static def shouldIndexExistingMultiplicites(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
-        
+                constrainsUnfinished || (indexUpperMultiplicities && constrainsRemainingContents)
-        def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)
-                '''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''
-        
-        def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {
-                val parameters = lowerMultiplicityAssertion.relation.parameters
-                if(parameters.size == 2) {
-                        val firstParam = parameters.get(0)
-                        if(firstParam instanceof ComplexTypeReference) {
-                                return firstParam.referred
-                        }
-                }
        }
-        
-        def getUnfinishedMultiplicityQueries(LogicProblem problem) {
+        static def shouldIndexRepairMultiplcities(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
-                val lowerMultiplicities = base.lowerMultiplicities(problem)
+                shouldIndexExistingMultiplicites(indexUpperMultiplicities) && constrainsUnrepairable
-                val map = new LinkedHashMap
+        }
-                for(lowerMultiplicity : lowerMultiplicities) {
-                        map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity))
+        static def shouldIndexInverseMultiplicites(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
-                }
+                indexUpperMultiplicities && constrainsRemainingInverse
-                return map
+        }
+        static def shouldIndexRepairMatches(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
+                shouldIndexRepairMultiplcities(indexUpperMultiplicities) ||
+                        shouldIndexInverseMultiplicites(indexUpperMultiplicities)
        }
 }

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..65ad3d48 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,149 @@
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 existingMultiplicityQueryName
		18	val String existingInverseMultiplicityQueryName
		19	}
13		20
14	class UnfinishedIndexer {	21	class UnfinishedIndexer {
15	val PatternGenerator base	22	val PatternGenerator base
16		23	val boolean indexUpperMultiplicities
17	new(PatternGenerator patternGenerator) {	24
		25	new(PatternGenerator patternGenerator, boolean indexUpperMultiplicities) {
18	this.base = patternGenerator	26	this.base = patternGenerator
		27	this.indexUpperMultiplicities = indexUpperMultiplicities
19	}	28	}
20		29
21	def generateUnfinishedWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {	30	def generateUnfinishedWfQueries(LogicProblem problem, Map<String, PQuery> fqn2PQuery) {
22	val wfQueries = base.wfQueries(problem)	31	val wfQueries = base.wfQueries(problem)
23	'''	32	'''
24	«FOR wfQuery: wfQueries»	33	«FOR wfQuery : wfQueries»
25	pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,	34	pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
26	«FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)	35	«FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
27	{	36	{
28	«base.relationDefinitionIndexer.referPattern(	37	«base.relationDefinitionIndexer.referPattern(
29	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),	38	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),
30	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],	39	wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],
31	Modality.CURRENT,	40	Modality.CURRENT,
32	true,false)»	41	true,false)»
33	}	42	}
34	«ENDFOR»	43	«ENDFOR»
35	'''	44	'''
36	}	45	}
		46
37	def getUnfinishedWFQueryNames(LogicProblem problem) {	47	def getUnfinishedWFQueryNames(LogicProblem problem) {
38	val wfQueries = base.wfQueries(problem)	48	val wfQueries = base.wfQueries(problem)
39	val map = new LinkedHashMap	49	val map = new LinkedHashMap
40	for(wfQuery : wfQueries) {	50	for (wfQuery : wfQueries) {
41	map.put(wfQuery.target,'''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')	51	map.put(wfQuery.target, '''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')
42	}	52	}
43	return map	53	return map
44	}	54	}
45	def generateUnfinishedMultiplicityQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {	55
46	val lowerMultiplicities = base.lowerMultiplicities(problem)	56	def generateUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints,
47	return '''	57	Map<String, PQuery> fqn2PQuery) '''
48	«FOR lowerMultiplicity : lowerMultiplicities»	58	«FOR constraint : constraints»
49	pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) {	59	«IF constraint.shouldIndexExistingMultiplicites(indexUpperMultiplicities)»
50	find interpretation(problem,interpretation);	60	private pattern «existingMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer«IF constraint.shouldIndexRepairMultiplcities(indexUpperMultiplicities)», numberOfRepairMatches: java Integer«ENDIF») {
51	PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);	61	find interpretation(problem,interpretation);
52	PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»");	62	find mustExist(problem,interpretation,object);
53	«base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")»	63	«base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"object")»
54	numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)»	64	numberOfExistingReferences == count «base.referRelation(constraint.relation,"object","_",Modality.MUST,fqn2PQuery)»
55	check(numberOfExistingReferences < «lowerMultiplicity.lower»);	65	«IF constraint.shouldIndexRepairMultiplcities(indexUpperMultiplicities)»
56	missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);	66	numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, object, _);
57	}	67	«ENDIF»
		68	}
		69	«ENDIF»
		70
		71	«IF constraint.shouldIndexRepairMatches(indexUpperMultiplicities)»
		72	private pattern «repairMatchName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, source:DefinedElement, target:DefinedElement) {
		73	«IF constraint.containment \|\| constraint.container»
		74	«repairMatchFallback(constraint, fqn2PQuery)»
		75	«ELSEIF base.isRepresentative(constraint.relation, constraint.inverseRelation) && constraint.relation instanceof RelationDeclaration»
		76	«base.relationRefinementGenerator.referRefinementQuery(constraint.relation as RelationDeclaration, constraint.inverseRelation, "_", "_", "source", "target")»
		77	«ELSEIF base.isRepresentative(constraint.inverseRelation, constraint.relation) && constraint.inverseRelation instanceof RelationDeclaration»
		78	«base.relationRefinementGenerator.referRefinementQuery(constraint.inverseRelation as RelationDeclaration, constraint.relation, "_", "_", "target", "source")»
		79	«ELSE»
		80	«repairMatchFallback(constraint, fqn2PQuery)»
		81	«ENDIF»
		82	}
		83	«ENDIF»
		84
		85	«IF constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)»
		86	private pattern «existingInverseMultiplicityName(constraint)»(problem:LogicProblem, interpretation:PartialInterpretation, object:DefinedElement, numberOfExistingReferences:java Integer, numberOfRepairMatches: java Integer) {
		87	find interpretation(problem,interpretation);
		88	find mustExist(problem,interpretation,object);
		89	«base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"object")»
		90	numberOfExistingReferences == count «base.referRelation(constraint.relation,"_","object",Modality.MUST,fqn2PQuery)»
		91	numberOfRepairMatches == count find «repairMatchName(constraint)»(problem, interpretation, _, object);
		92	}
		93	«ENDIF»
58	«ENDFOR»	94	«ENDFOR»
59	'''	95	'''
		96
		97	private def repairMatchFallback(RelationMultiplicityConstraint constraint, Map<String, PQuery> fqn2PQuery) '''
		98	find interpretation(problem,interpretation);
		99	find mustExist(problem,interpretation,source);
		100	«base.typeIndexer.referInstanceOf(constraint.sourceType,Modality::MUST,"source")»
		101	find mustExist(problem,interpretation,target);
		102	«base.typeIndexer.referInstanceOf(constraint.targetType,Modality::MUST,"target")»
		103	neg «base.referRelation(constraint.relation,"source","target",Modality.MUST,fqn2PQuery)»
		104	«base.referRelation(constraint.relation,"source","target",Modality.MAY,fqn2PQuery)»
		105	'''
		106
		107	def String existingMultiplicityName(
		108	RelationMultiplicityConstraint constraint) '''existingMultiplicity_«base.canonizeName(constraint.relation.name)»'''
		109
		110	def String existingInverseMultiplicityName(
		111	RelationMultiplicityConstraint constraint) '''existingInverseMultiplicity_«base.canonizeName(constraint.relation.name)»'''
		112
		113	private def String repairMatchName(
		114	RelationMultiplicityConstraint constraint) '''repair_«base.canonizeName(constraint.relation.name)»'''
		115
		116	def getUnfinishedMultiplicityQueries(List<RelationMultiplicityConstraint> constraints) {
		117	constraints.toInvertedMap [ constraint \|
		118	new UnifinishedMultiplicityQueryNames(
		119	if (constraint.shouldIndexExistingMultiplicites(indexUpperMultiplicities)) {
		120	existingMultiplicityName(constraint)
		121	} else {
		122	null
		123	},
		124	if (constraint.shouldIndexInverseMultiplicites(indexUpperMultiplicities)) {
		125	existingInverseMultiplicityName(constraint)
		126	} else {
		127	null
		128	}
		129	)
		130	]
60	}	131	}
61	def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion)	132
62	'''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''	133	static def shouldIndexExistingMultiplicites(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
63		134	constrainsUnfinished \|\| (indexUpperMultiplicities && constrainsRemainingContents)
64	def public referUnfinishedMultiplicityQuery(LowerMultiplicityAssertion lowerMultiplicityAssertion)
65	'''find «unfinishedMultiplicityName(lowerMultiplicityAssertion)»(problem, interpretation ,object, missingMultiplicity);'''
66
67	def getFirstParamTypeOfRelation(LowerMultiplicityAssertion lowerMultiplicityAssertion) {
68	val parameters = lowerMultiplicityAssertion.relation.parameters
69	if(parameters.size == 2) {
70	val firstParam = parameters.get(0)
71	if(firstParam instanceof ComplexTypeReference) {
72	return firstParam.referred
73	}
74	}
75	}	135	}
76		136
77	def getUnfinishedMultiplicityQueries(LogicProblem problem) {	137	static def shouldIndexRepairMultiplcities(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
78	val lowerMultiplicities = base.lowerMultiplicities(problem)	138	shouldIndexExistingMultiplicites(indexUpperMultiplicities) && constrainsUnrepairable
79	val map = new LinkedHashMap	139	}
80	for(lowerMultiplicity : lowerMultiplicities) {	140
81	map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity))	141	static def shouldIndexInverseMultiplicites(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
82	}	142	indexUpperMultiplicities && constrainsRemainingInverse
83	return map	143	}
		144
		145	static def shouldIndexRepairMatches(RelationMultiplicityConstraint it, boolean indexUpperMultiplicities) {
		146	shouldIndexRepairMultiplcities(indexUpperMultiplicities) \|\|
		147	shouldIndexInverseMultiplicites(indexUpperMultiplicities)
84	}	148	}
85	}	149	}