diff options
author | 20001LastOrder <boqi.chen@mail.mcgill.ca> | 2020-11-04 01:33:58 -0500 |
---|---|---|
committer | 20001LastOrder <boqi.chen@mail.mcgill.ca> | 2020-11-04 01:33:58 -0500 |
commit | a20af4d0dbf5eab84ee271d426528aabb5a8ac3b (patch) | |
tree | a9ab772ee313125aaf3a941d66e131b408d949ba /Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend | |
parent | changes in settings of measurements (diff) | |
parent | merge with current master, comment numerical solver related logging (diff) | |
download | VIATRA-Generator-a20af4d0dbf5eab84ee271d426528aabb5a8ac3b.tar.gz VIATRA-Generator-a20af4d0dbf5eab84ee271d426528aabb5a8ac3b.tar.zst VIATRA-Generator-a20af4d0dbf5eab84ee271d426528aabb5a8ac3b.zip |
fix merging issue
Diffstat (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend')
-rw-r--r-- | Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend | 172 |
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 @@ | |||
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 | } |