aboutsummaryrefslogtreecommitdiffstats
path: root/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns
diff options
context:
space:
mode:
authorLibravatar OszkarSemerath <oszka@152.66.252.189>2017-06-10 19:05:05 +0200
committerLibravatar OszkarSemerath <oszka@152.66.252.189>2017-06-10 19:05:05 +0200
commit60f01f46ba232ed6416054f0a6115cb2a9b70b4e (patch)
tree5edf8aeb07abc51f3fec63bbd15c926e1de09552 /Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns
parentInitial commit, migrating from SVN (diff)
downloadVIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.gz
VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.zst
VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.zip
Migrating Additional projects
Diffstat (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns')
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/ContainmentIndexer.xtend41
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend194
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend102
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/InvalidIndexer.xtend53
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend244
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend96
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend154
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend185
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend93
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RepairGenerator.xtend18
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend16
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend97
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend95
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend105
-rw-r--r--Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend85
15 files changed, 1578 insertions, 0 deletions
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/ContainmentIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/ContainmentIndexer.xtend
new file mode 100644
index 00000000..02e58c9b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/ContainmentIndexer.xtend
@@ -0,0 +1,41 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
4import java.util.Collection
5import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
6import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
7import java.util.Map
8import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
9
10class ContainmentIndexer {
11 val PatternGenerator base;
12
13 new(PatternGenerator base) {
14 this.base = base
15 }
16
17 def isContainmentRelation(Relation relation, LogicProblem problem) {
18 problem.containmentHierarchies.exists[it.containmentRelations.contains(relation)]
19 }
20
21 def transformContainment(LogicProblem problem, Collection<Relation> relations,Map<String,PQuery> fqn2PQuery)
22 '''
23 private pattern mustContains2(source: DefinedElement, target: DefinedElement) {
24 find mustContains4(_,_,source,target);
25 }
26
27 private pattern mustContains4(problem:LogicProblem, interpretation:PartialInterpretation,
28 source: DefinedElement, target: DefinedElement)
29 «FOR reference : relations.filter[isContainmentRelation(problem)] SEPARATOR 'or\n'»
30 { «base.referRelation(reference,"source","target",Modality.MUST,fqn2PQuery)» }
31 «ENDFOR»
32
33 private pattern mustTransitiveContains(source,target) {
34 find mustContains2+(source,target);
35 }
36 '''
37 def referMustContaint(String source, String target)
38 '''find mustContains4(problem,interpretation,«source»,«target»);'''
39 def referTransitiveMustContains(String source, String target)
40 '''find mustTransitiveContains(source,target);'''
41}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
new file mode 100644
index 00000000..fbbd9fb5
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeIndexer.xtend
@@ -0,0 +1,194 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
5import org.eclipse.emf.ecore.EClass
6import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
7import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
8import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
9
10class GenericTypeIndexer implements TypeIndexer {
11 val PatternGenerator base;
12
13 new(PatternGenerator base) {
14 this.base = base
15 }
16 override requiresTypeAnalysis() { false }
17
18 public override getRequiredQueries() '''
19 private pattern newELement(interpretation: PartialInterpretation, element: DefinedElement) {
20 PartialInterpretation.newElements(interpretation,element);
21 }
22
23 private pattern typeInterpretation(problem:LogicProblem, interpetation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialTypeInterpratation) {
24 find interpretation(problem,interpetation);
25 LogicProblem.types(problem,type);
26 PartialInterpretation.partialtypeinterpratation(interpetation,typeInterpretation);
27 PartialTypeInterpratation.interpretationOf(typeInterpretation,type);
28 }
29
30 private pattern directInstanceOf(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement, type:Type) {
31 find interpretation(problem,interpetation);
32 find mustExist(problem,interpetation,element);
33 LogicProblem.types(problem,type);
34 TypeDefinition.elements(type,element);
35 } or {
36 find mustExist(problem,interpetation,element);
37 find typeInterpretation(problem,interpetation,type,typeInterpretation);
38 PartialTypeInterpratation.elements(typeInterpretation,element);
39 }
40
41 /**
42 * Direct supertypes of a type.
43 */
44 private pattern supertypeDirect(subtype : Type, supertype : Type) {
45 Type.supertypes(subtype, supertype);
46 }
47
48 /**
49 * All supertypes of a type.
50 */
51 private pattern supertypeStar(subtype: Type, supertype: Type) {
52 subtype == supertype;
53 } or {
54 find supertypeDirect+(subtype,supertype);
55 }
56
57 /// Complex type reasoning patterns ///
58 //
59 // In a valid type system, for each element e there is exactly one type T where
60 // 1: T(e) - but we dont know this for type declaration
61 // 2: For the dynamic type D and another type T, where D(e) && D-->T, T(e) is true.
62 // 2e: A type hierarchy is invalid, if there is a supertype T for a dynamic type D which does no contains e:
63 // D(e) && D-->T && !T(e)
64 // 3: There is no T' that T'->T and T'(e)
65 // 3e: A type hierarcy is invalid, if there is a type T for a dynamic type D, which contains e, but not subtype of T:
66 // D(e) && ![T--->D] && T(e)
67 // 4: T is not abstract
68 // Such type T is called Dynamic type of e, while other types are called static types.
69 //
70 // The following patterns checks the possible dynamic types for an element
71
72 private pattern wellformedType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement) {
73 // 1: T(e)
74 find directInstanceOf(problem,interpretation,element,dynamic);
75 // 2e is not true: D(e) && D-->T && !T(e)
76 neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic);
77 // 3e is not true: D(e) && ![T--->D] && T(e)
78 neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic);
79 // 4: T is not abstract
80 Type.isAbstract(dynamic,false);
81 }
82
83 private pattern possibleDynamicType(problem: LogicProblem, interpretation:PartialInterpretation, dynamic:Type, element:DefinedElement)
84 // case 1: element is defined at least once
85 {
86 LogicProblem.types(problem,dynamic);
87 // select a random definition 'randomType'
88 find directInstanceOf(problem,interpretation,element,randomType);
89 // dynamic is a subtype of 'randomType'
90 find supertypeStar(dynamic,randomType);
91 // 2e is not true: D(e) && D-->T && !T(e)
92 neg find dynamicTypeNotSubtypeOfADefinition(problem,interpretation,element,dynamic);
93 // 3e is not true: D(e) && ![T--->D] && T(e)
94 neg find dynamicTypeIsSubtypeOfANonDefinition(problem,interpretation,element,dynamic);
95 // 4: T is not abstract
96 Type.isAbstract(dynamic,false);
97 } or
98 // case 2: element is not defined anywhere
99 {
100 find mayExist(problem,interpretation,element);
101 // there is no definition
102 neg find directInstanceOf(problem,interpretation,element,_);
103 // 2e is not true: D(e) && D-->T && !T(e)
104 // because non of the definition contains element, the type cannot have defined supertype
105 LogicProblem.types(problem,dynamic);
106 PartialInterpretation.problem(interpretation,problem);
107 neg find typeWithDefinedSupertype(dynamic);
108 // 3e is not true: D(e) && ![T--->D] && T(e)
109 // because there is no definition, dynamic covers all definition
110 // 4: T is not abstract
111 Type.isAbstract(dynamic,false);
112 }
113
114 /**
115 * supertype -------> element <------- otherSupertype
116 * A A
117 * | |
118 * wrongDynamic -----------------------------X
119 */
120 private pattern dynamicTypeNotSubtypeOfADefinition(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic : Type) {
121 find directInstanceOf(problem,interpretation,element,supertype);
122 find directInstanceOf(problem,interpretation,element,otherSupertype);
123 find supertypeStar(wrongDynamic,supertype);
124 neg find supertypeStar(wrongDynamic,otherSupertype);
125 }
126
127 /**
128 * supertype -------> element <---X--- otherSupertype
129 * A A
130 * | |
131 * wrongDynamic -----------------------------+
132 */
133 private pattern dynamicTypeIsSubtypeOfANonDefinition(problem: LogicProblem, interpretation:PartialInterpretation, element:DefinedElement, wrongDynamic:Type) {
134 find directInstanceOf(problem,interpretation,element,supertype);
135 neg find elementInTypeDefinition(element,otherSupertype);
136 TypeDefinition(otherSupertype);
137 find supertypeStar(wrongDynamic, supertype);
138 find supertypeStar(wrongDynamic, otherSupertype);
139 }
140
141 private pattern elementInTypeDefinition(element:DefinedElement, definition:TypeDefinition) {
142 TypeDefinition.elements(definition,element);
143 }
144
145 private pattern typeWithDefinedSupertype(type:Type) {
146 find supertypeStar(type,definedSupertype);
147 TypeDefinition(definedSupertype);
148 }
149 '''
150
151 public override generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult) {
152 '''
153 «FOR type:problem.types»
154 «problem.generateMustInstenceOf(type)»
155 «problem.generateMayInstanceOf(type)»
156 «ENDFOR»
157 '''
158 }
159
160 private def patternName(Type type, Modality modality)
161 '''«modality.toString.toLowerCase»InstanceOf«base.canonizeName(type.name)»'''
162
163 private def generateMustInstenceOf(LogicProblem problem, Type type) {
164 '''
165 /**
166 * An element must be an instance of type "«type.name»".
167 */
168 private pattern «patternName(type,Modality.MUST)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
169 Type.name(type,"«type.name»");
170 find directInstanceOf(problem,interpretation,element,type);
171 }
172 '''
173 }
174
175 private def generateMayInstanceOf(LogicProblem problem, Type type) {
176 '''
177 /**
178 * An element may be an instance of type "«type.name»".
179 */
180 private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
181 Type.name(type,"«type.name»");
182 find possibleDynamicType(problem,interpretation,dynamic,element);
183 find supertypeStar(dynamic,type);
184 }
185 '''
186 }
187
188 public override referInstanceOf(Type type, Modality modality, String variableName) {
189 '''find «patternName(type,modality)»(problem,interpretation,«variableName»);'''
190 }
191 public override referInstanceOf(EClass type, Modality modality, String variableName) {
192 '''find «modality.toString.toLowerCase»InstanceOf«base.canonizeName('''class «type.name»''')»(problem,interpretation,«variableName»);'''
193 }
194} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend
new file mode 100644
index 00000000..4b7af959
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/GenericTypeRefinementGenerator.xtend
@@ -0,0 +1,102 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
5import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
6import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
7import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
8import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
9import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
10import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
11import java.util.HashMap
12
13class GenericTypeRefinementGenerator extends TypeRefinementGenerator {
14 public new(PatternGenerator base) {
15 super(base)
16 }
17 override requiresTypeAnalysis() { false }
18
19 override generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
20 val containment = p.containmentHierarchies.head
21 val newObjectTypes = p.types.filter(TypeDeclaration).filter[!isAbstract]
22 val inverseRelations = new HashMap
23 p.annotations.filter(InverseRelationAssertion).forEach[
24 inverseRelations.put(it.inverseA,it.inverseB)
25 inverseRelations.put(it.inverseB,it.inverseA)
26 ]
27 return '''
28 «FOR type:newObjectTypes»
29 «IF(containment.typesOrderedInHierarchy.contains(type))»
30 «FOR containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]»
31 «IF inverseRelations.containsKey(containmentRelation)»
32 pattern «this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)»(
33 problem:LogicProblem, interpretation:PartialInterpretation,
34 relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation ,typeInterpretation:PartialTypeInterpratation,
35 container:DefinedElement)
36 {
37 find interpretation(problem,interpretation);
38 PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
39 PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»");
40 PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
41 PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
42 PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation);
43 PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"«inverseRelations.get(containmentRelation).name»");
44 «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
45 «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
46 «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
47 find mustExist(problem, interpretation, container);
48 neg find mustExist(problem, interpretation, newObject);
49 }
50 «ELSE»
51 pattern «this.patternName(containmentRelation,null,type)»(
52 problem:LogicProblem, interpretation:PartialInterpretation,
53 relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialTypeInterpratation,
54 container:DefinedElement)
55 {
56 find interpretation(problem,interpretation);
57 PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
58 PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»");
59 PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
60 PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
61 «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
62 «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
63 «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
64 find mustExist(problem, interpretation, container);
65 neg find mustExist(problem, interpretation, newObject);
66 }
67 «ENDIF»
68 «ENDFOR»
69 «ELSE»
70 pattern createObject_«this.patternName(null,null,type)»(
71 problem:LogicProblem, interpretation:PartialInterpretation,
72 typeInterpretation:PartialTypeInterpratation)
73 {
74 find interpretation(problem,interpretation);
75 PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
76 PartialTypeInterpratation.interpretationOf.name(type,"«type.name»");
77 «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
78 find mayExist(problem, interpretation, newObject);
79 neg find mustExist(problem, interpretation, newObject);
80 }
81 «ENDIF»
82 «ENDFOR»
83 '''
84 }
85
86 override generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
87 return '''
88 «FOR type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]»
89 pattern refineTypeTo_«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation, object: DefinedElement) {
90 find interpretation(problem,interpretation);
91 find mustExist(problem, interpretation, object);
92 «base.typeIndexer.referInstanceOf(type,Modality.MAY,"object")»
93 neg «base.typeIndexer.referInstanceOf(type,Modality.MUST,"object")»
94 }
95 «ENDFOR»
96 '''
97 }
98
99 override getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
100 p.types.filter(TypeDeclaration).toInvertedMap['''refineTypeTo_«base.canonizeName(it.name)»''']
101 }
102} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/InvalidIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/InvalidIndexer.xtend
new file mode 100644
index 00000000..d9ede2a8
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/InvalidIndexer.xtend
@@ -0,0 +1,53 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
4import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint
5import java.util.Map
6import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
7
8import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.lookup
9import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition
10import java.util.LinkedHashMap
11import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
12
13class InvalidIndexer {
14 val PatternGenerator patternGenerator
15
16 public new(PatternGenerator patternGenerator) {
17 this.patternGenerator = patternGenerator
18 }
19
20 public def getWFQueryName(RelationDefinition query) '''invalidWFQuery_«patternGenerator.canonizeName(query.name)»'''
21
22 public def generateInvalidatedByWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {
23 val wfQueries = problem.assertions.map[it.annotations]
24 .flatten
25 .filter(TransformedViatraWellformednessConstraint)
26 .map[it.query]
27 '''
28 «FOR wfQuery: wfQueries»
29 pattern invalidatedBy_«patternGenerator.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
30 «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
31 {
32 «patternGenerator.relationDefinitionIndexer.referPattern(
33 wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),
34 wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],
35 Modality.MUST,
36 true,false)»
37 }
38 «ENDFOR»
39 '''
40 }
41
42 public def getInvalidateByWfQueryNames(LogicProblem problem) {
43 val wfQueries = problem.assertions.map[it.annotations]
44 .flatten
45 .filter(TransformedViatraWellformednessConstraint)
46 .map[it.query]
47 val map = new LinkedHashMap
48 for(wfQuery : wfQueries) {
49 map.put(wfQuery.target, '''invalidatedBy_«patternGenerator.canonizeName(wfQuery.target.name)»''')
50 }
51 return map
52 }
53}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
new file mode 100644
index 00000000..291b605b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternGenerator.xtend
@@ -0,0 +1,244 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition
5import java.util.Map
6import org.eclipse.emf.ecore.EReference
7import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
8import org.eclipse.xtend.lib.annotations.Accessors
9import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery
10import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
11import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
12import org.eclipse.emf.ecore.EAttribute
13import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
14import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
15import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod
16import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
17import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
18import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint
19import java.util.HashMap
20import java.util.HashSet
21import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
22import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
23import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.DefinedByDerivedFeature
24
25class PatternGenerator {
26 @Accessors(PUBLIC_GETTER) val TypeIndexer typeIndexer //= new TypeIndexer(this)
27 @Accessors(PUBLIC_GETTER) val RelationDeclarationIndexer relationDeclarationIndexer = new RelationDeclarationIndexer(this)
28 @Accessors(PUBLIC_GETTER) val RelationDefinitionIndexer relationDefinitionIndexer = new RelationDefinitionIndexer(this)
29 @Accessors(PUBLIC_GETTER) val ContainmentIndexer containmentIndexer = new ContainmentIndexer(this)
30 @Accessors(PUBLIC_GETTER) val InvalidIndexer invalidIndexer = new InvalidIndexer(this)
31 @Accessors(PUBLIC_GETTER) val UnfinishedIndexer unfinishedIndexer = new UnfinishedIndexer(this)
32 @Accessors(PUBLIC_GETTER) val TypeRefinementGenerator typeRefinementGenerator //= new RefinementGenerator(this)
33 @Accessors(PUBLIC_GETTER) val RelationRefinementGenerator relationRefinementGenerator = new RelationRefinementGenerator(this)
34
35 public new(TypeInferenceMethod typeInferenceMethod) {
36 if(typeInferenceMethod == TypeInferenceMethod.Generic) {
37 this.typeIndexer = new GenericTypeIndexer(this)
38 this.typeRefinementGenerator = new GenericTypeRefinementGenerator(this)
39 } else if(typeInferenceMethod == TypeInferenceMethod.PreliminaryAnalysis) {
40 this.typeIndexer = new TypeIndexerWithPreliminaryTypeAnalysis(this)
41 this.typeRefinementGenerator = new TypeRefinementWithPreliminaryTypeAnalysis(this)
42 } else {
43 this.typeIndexer = null
44 this.typeRefinementGenerator = null
45 throw new IllegalArgumentException('''Unknown type indexing technique : «typeInferenceMethod.name»''')
46 }
47 }
48
49 public def requiresTypeAnalysis() {
50 typeIndexer.requiresTypeAnalysis || typeRefinementGenerator.requiresTypeAnalysis
51 }
52
53 public dispatch def referRelation(
54 RelationDeclaration referred,
55 String sourceVariable,
56 String targetVariable,
57 Modality modality,
58 Map<String,PQuery> fqn2PQuery)
59 {
60 return this.relationDeclarationIndexer.referRelation(referred,sourceVariable,targetVariable,modality)
61 }
62 public dispatch def referRelation(
63 RelationDefinition referred,
64 String sourceVariable,
65 String targetVariable,
66 Modality modality,
67 Map<String,PQuery> fqn2PQuery)
68 {
69 val pattern = referred.annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery)
70 return this.relationDefinitionIndexer.referPattern(pattern,#[sourceVariable,targetVariable],modality,true,false)
71 }
72
73 def public referRelationByName(EReference reference,
74 String sourceVariable,
75 String targetVariable,
76 Modality modality)
77 {
78 '''find «modality.name.toLowerCase»InRelation«canonizeName('''inreference «reference.name» «reference.EContainingClass.name»''')
79 »(problem,interpretation,«sourceVariable»,«targetVariable»);'''
80 }
81
82 def public CharSequence referAttributeByName(EAttribute attribute,
83 String sourceVariable,
84 String targetVariable,
85 Modality modality)
86 {
87 throw new UnsupportedOperationException
88 }
89
90 public def canonizeName(String name) {
91 name.split(' ').join('_')
92 }
93
94 public def lowerMultiplicities(LogicProblem problem) {
95 problem.assertions.map[annotations].flatten.filter(LowerMultiplicityAssertion).filter[!it.relation.isDerived]
96 }
97 public def wfQueries(LogicProblem problem) {
98 problem.assertions.map[it.annotations]
99 .flatten
100 .filter(TransformedViatraWellformednessConstraint)
101 .map[it.query]
102 }
103 public def getContainments(LogicProblem p) {
104 return p.containmentHierarchies.head.containmentRelations
105 }
106 public def getInverseRelations(LogicProblem p) {
107 val inverseRelations = new HashMap
108 p.annotations.filter(InverseRelationAssertion).forEach[
109 inverseRelations.put(it.inverseA,it.inverseB)
110 inverseRelations.put(it.inverseB,it.inverseA)
111 ]
112 return inverseRelations
113 }
114 public def isRepresentative(Relation relation, Relation inverse) {
115 if(inverse == null) {
116 return true
117 } else {
118 relation.name.compareTo(inverse.name)<1
119 }
120 }
121
122 public def isDerived(Relation relation) {
123 relation.annotations.exists[it instanceof DefinedByDerivedFeature]
124 }
125 public def getDerivedDefinition(RelationDeclaration relation) {
126 relation.annotations.filter(DefinedByDerivedFeature).head.query
127 }
128
129 public def transformBaseProperties(
130 LogicProblem problem,
131 PartialInterpretation emptySolution,
132 Map<String,PQuery> fqn2PQuery,
133 TypeAnalysisResult typeAnalysisResult
134 ) {
135
136 return '''
137 import epackage "http://www.bme.hu/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage"
138 import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/problem"
139 import epackage "http://www.bme.hu/mit/inf/dslreasoner/logic/model/language"
140
141 //////////
142 // 0. Util
143 //////////
144 private pattern interpretation(problem:LogicProblem, interpetation:PartialInterpretation) {
145 PartialInterpretation.problem(interpetation,problem);
146 }
147
148 /////////////////////////
149 // 0.1 Existance
150 /////////////////////////
151 private pattern mustExist(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement) {
152 find interpretation(problem,interpetation);
153 LogicProblem.elements(problem,element);
154 } or {
155 find interpretation(problem,interpetation);
156 PartialInterpretation.newElements(interpetation,element);
157 }
158
159 private pattern mayExist(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement) {
160 find mustExist(problem,interpetation,element);
161 } or {
162 find interpretation(problem,interpetation);
163 neg find closeWorld(interpetation);
164 PartialInterpretation.openWorldElementPrototype(interpetation,element);
165 }
166
167 private pattern closeWorld(interpetation:PartialInterpretation) {
168 PartialInterpretation.maxNewElements(interpetation,0);
169 }
170
171 ////////////////////////
172 // 0.2 Equivalence
173 ////////////////////////
174 pattern mayEquivalent(problem:LogicProblem, interpretation:PartialInterpretation, a: DefinedElement, b: DefinedElement) {
175 find mayExist(problem,interpretation,a);
176 find mayExist(problem,interpretation,b);
177 a == b;
178 }
179
180 ////////////////////////
181 // 0.3 Required Patterns by TypeIndexer
182 ////////////////////////
183 «typeIndexer.requiredQueries»
184
185 //////////
186 // 1. Problem-Specific Base Indexers
187 //////////
188 // 1.1 Type Indexers
189 //////////
190 «typeIndexer.generateInstanceOfQueries(problem,emptySolution,typeAnalysisResult)»
191
192 //////////
193 // 1.2 Relation Declaration Indexers
194 //////////
195 «relationDeclarationIndexer.generateRelationIndexers(problem,problem.relations.filter(RelationDeclaration),fqn2PQuery)»
196
197 //////////
198 // 1.3 Relation Definition Indexers
199 //////////
200 «relationDefinitionIndexer.generateRelationDefinitions(problem,problem.relations.filter(RelationDefinition),fqn2PQuery)»
201
202 //////////
203 // 1.4 Containment Indexer
204 //////////
205 «containmentIndexer.transformContainment(problem,problem.relations,fqn2PQuery)»
206
207 //////////
208 // 2. Invalidation Indexers
209 //////////
210 // 2.1 Invalidated by WF Queries
211 //////////
212 «invalidIndexer.generateInvalidatedByWfQueries(problem,fqn2PQuery)»
213
214 //////////
215 // 3. Unfinishedness Indexers
216 //////////
217 // 3.1 Unfinishedness Measured by Multiplicity
218 //////////
219 «unfinishedIndexer.generateUnfinishedMultiplicityQueries(problem,fqn2PQuery)»
220
221 //////////
222 // 3.2 Unfinishedness Measured by WF Queries
223 //////////
224 «unfinishedIndexer.generateUnfinishedWfQueries(problem,fqn2PQuery)»
225
226 //////////
227 // 4. Refinement Indexers
228 //////////
229 // 4.1 Object constructors
230 //////////
231 «typeRefinementGenerator.generateRefineObjectQueries(problem,emptySolution,typeAnalysisResult)»
232
233 //////////
234 // 4.2 Type refinement
235 //////////
236 «typeRefinementGenerator.generateRefineTypeQueries(problem,emptySolution,typeAnalysisResult)»
237
238 //////////
239 // 4.3 Relation refinement
240 //////////
241 «relationRefinementGenerator.generateRefineReference(problem)»
242 '''
243 }
244}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
new file mode 100644
index 00000000..dac5630b
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/PatternProvider.xtend
@@ -0,0 +1,96 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
5import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
6import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
7import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.ModelGenerationStatistics
8import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysis
9import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
10import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeInferenceMethod
11import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.util.ParseUtil
12import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
13import hu.bme.mit.inf.dslreasoner.workspace.ReasonerWorkspace
14import java.util.Map
15import org.eclipse.viatra.query.runtime.api.IPatternMatch
16import org.eclipse.viatra.query.runtime.api.IQuerySpecification
17import org.eclipse.viatra.query.runtime.api.ViatraQueryMatcher
18import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
19import org.eclipse.xtend.lib.annotations.Data
20
21import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
22
23@Data class GeneratedPatterns {
24 public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> invalidWFQueries
25 public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedWFQueries
26 public Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> unfinishedMulticiplicityQueries
27 public Map<ObjectCreationPrecondition, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineObjectQueries
28 public Map<? extends Type, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refineTypeQueries
29 public Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> refinerelationQueries
30}
31
32class PatternProvider {
33 val ParseUtil parseUtil = new ParseUtil
34 val TypeAnalysis typeAnalysis = new TypeAnalysis
35
36 public def generateQueries(
37 LogicProblem problem,
38 PartialInterpretation emptySolution,
39 ModelGenerationStatistics statistics,
40 Iterable<PQuery> existingQueries,
41 ReasonerWorkspace workspace,
42 TypeInferenceMethod typeInferenceMethod
43 ) {
44 val fqn2Query = existingQueries.toMap[it.fullyQualifiedName]
45 val PatternGenerator patternGenerator = new PatternGenerator(typeInferenceMethod)
46 val typeAnalysisResult = if(patternGenerator.requiresTypeAnalysis) {
47 val startTime = System.nanoTime
48 val result = typeAnalysis.performTypeAnalysis(problem,emptySolution)
49 val typeAnalysisTime = System.nanoTime - startTime
50 statistics.PreliminaryTypeAnalisisTime = typeAnalysisTime
51 result
52 } else {
53 null
54 }
55 val baseIndexerFile = patternGenerator.transformBaseProperties(problem,emptySolution,fqn2Query,typeAnalysisResult)
56 writeQueries(baseIndexerFile,"GeneratedQueries",workspace)
57 val generatedQueries = parseUtil.parse(baseIndexerFile)
58 val runtimeQueries = calclulateRuntimeQueries(patternGenerator,problem,emptySolution,typeAnalysisResult,generatedQueries);
59 return runtimeQueries
60 }
61
62 private def writeQueries(CharSequence content, String name,ReasonerWorkspace workspace) {
63 if(workspace!=null) {
64 workspace.writeText('''«name».vql_deactivated''',content)
65 }
66 }
67
68 private def GeneratedPatterns calclulateRuntimeQueries(
69 PatternGenerator patternGenerator,
70 LogicProblem problem,
71 PartialInterpretation emptySolution,
72 TypeAnalysisResult typeAnalysisResult,
73 Map<String, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>> queries
74 ) {
75 val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
76 invalidWFQueries = patternGenerator.invalidIndexer.getInvalidateByWfQueryNames(problem).mapValues[it.lookup(queries)]
77 val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
78 unfinishedWFQueries = patternGenerator.unfinishedIndexer.getUnfinishedWFQueryNames(problem).mapValues[it.lookup(queries)]
79 val Map<Relation, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
80 unfinishedMultiplicityQueries = patternGenerator.unfinishedIndexer.getUnfinishedMultiplicityQueries(problem).mapValues[it.lookup(queries)]
81 val Map<ObjectCreationPrecondition, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
82 refineObjectsQueries = patternGenerator.typeRefinementGenerator.getRefineObjectQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)]
83 val Map<? extends Type, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
84 refineTypeQueries = patternGenerator.typeRefinementGenerator.getRefineTypeQueryNames(problem,emptySolution,typeAnalysisResult).mapValues[it.lookup(queries)]
85 val Map<Pair<RelationDeclaration, Relation>, IQuerySpecification<? extends ViatraQueryMatcher<? extends IPatternMatch>>>
86 refineRelationQueries = patternGenerator.relationRefinementGenerator.getRefineRelationQueries(problem).mapValues[it.lookup(queries)]
87 return new GeneratedPatterns(
88 invalidWFQueries,
89 unfinishedWFQueries,
90 unfinishedMultiplicityQueries,
91 refineObjectsQueries,
92 refineTypeQueries,
93 refineRelationQueries
94 )
95 }
96}
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
new file mode 100644
index 00000000..e6d92cc6
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDeclarationIndexer.xtend
@@ -0,0 +1,154 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.UpperMultiplicityAssertion
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
5import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
6import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
7import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeReference
8import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
9import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
10import java.util.HashMap
11import java.util.List
12import java.util.Map
13import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
14
15import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
16
17class RelationDeclarationIndexer {
18 val PatternGenerator base;
19
20 new(PatternGenerator base) {
21 this.base = base
22 }
23
24 public def generateRelationIndexers(LogicProblem problem, Iterable<RelationDeclaration> relations, Map<String,PQuery> fqn2PQuery) {
25 val upperMultiplicities = new HashMap
26 problem.annotations.filter(UpperMultiplicityAssertion).forEach[
27 upperMultiplicities.put(it.relation,it.upper)
28 ]
29
30 return '''
31 «FOR relation : relations»
32 «IF base.isDerived(relation)»
33 «generateDerivedMustRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
34 «generateDerivedMayRelation(problem,relation,base.getDerivedDefinition(relation).patternFullyQualifiedName.lookup(fqn2PQuery))»
35 «ELSE»
36 «generateMustRelation(problem,relation)»
37 «generateMayRelation(problem,relation,upperMultiplicities,base.getContainments(problem),base.getInverseRelations(problem),fqn2PQuery)»
38 «ENDIF»
39 «ENDFOR»
40 '''
41 }
42
43 def private patternName(RelationDeclaration r, Modality modality) {
44 '''«modality.name.toLowerCase»InRelation«base.canonizeName(r.name)»'''
45 }
46
47 public def referRelation(
48 RelationDeclaration referred,
49 String sourceVariable,
50 String targetVariable,
51 Modality modality)
52 '''find «referred.patternName(modality)»(problem,interpretation,«sourceVariable»,«targetVariable»);'''
53
54 def generateMustRelation(LogicProblem problem, RelationDeclaration relation) '''
55 /**
56 * Matcher for detecting tuples t where []«relation.name»(source,target)
57 */
58 private pattern «relation.patternName(Modality.MUST)»(
59 problem:LogicProblem, interpretation:PartialInterpretation,
60 source: DefinedElement, target:DefinedElement)
61 {
62 find interpretation(problem,interpretation);
63 PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
64 PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relation.name»");
65 PartialRelationInterpretation.relationlinks(relationIterpretation,link);
66 BinaryElementRelationLink.param1(link,source);
67 BinaryElementRelationLink.param2(link,target);
68 }
69 '''
70 def generateMayRelation(LogicProblem problem, RelationDeclaration relation,
71 Map<Relation, Integer> upperMultiplicities,
72 List<Relation> containments,
73 HashMap<Relation, Relation> inverseRelations,
74 Map<String,PQuery> fqn2PQuery)
75 {
76 return '''
77 /**
78 * Matcher for detecting tuples t where <>«relation.name»(source,target)
79 */
80 private pattern «relation.patternName(Modality.MAY)»(
81 problem:LogicProblem, interpretation:PartialInterpretation,
82 source: DefinedElement, target:DefinedElement)
83 {
84 find interpretation(problem,interpretation);
85 // The two endpoint of the link have to exist
86 find mayExist(problem, interpretation, source);
87 find mayExist(problem, interpretation, target);
88 // Type consistency
89 «transformTypeConsistency(relation.parameters.get(0),"source")»
90 «transformTypeConsistency(relation.parameters.get(1),"target")»
91 «IF upperMultiplicities.containsKey(relation)»
92 // There are "numberOfExistingReferences" currently existing instances of the reference from the source,
93 // the upper bound of the multiplicity should be considered.
94 numberOfExistingReferences == count «referRelation(relation,"source","_",Modality.MUST)»
95 check(numberOfExistingReferences < «upperMultiplicities.get(relation)»);
96 «ENDIF»
97 «IF inverseRelations.containsKey(relation) && upperMultiplicities.containsKey(inverseRelations.get(relation))»
98 // There are "numberOfExistingReferences" currently existing instances of the reference to the target,
99 // the upper bound of the opposite reference multiplicity should be considered.
100 numberOfExistingOppositeReferences == count «base.referRelation(inverseRelations.get(relation),"target","_",Modality.MUST,fqn2PQuery)»
101 check(numberOfExistingOppositeReferences < «upperMultiplicities.get(inverseRelations.get(relation))»);
102 «ENDIF»
103 «IF containments.contains(relation)»
104 // The reference is containment, then a new reference cannot be create if:
105 // 1. Multiple parents
106 neg «base.containmentIndexer.referMustContaint("_","target")»
107 // 2. Circle in the containment hierarchy
108 neg «base.containmentIndexer.referTransitiveMustContains("target","source")»
109 «ENDIF»
110 «IF inverseRelations.containsKey(relation) && containments.contains(inverseRelations.get(relation))»
111 // The eOpposite of the reference is containment, then a referene cannot be created if
112 // 1. Multiple parents
113 neg «base.containmentIndexer.referMustContaint("source","_")»
114 // 2. Circle in the containment hierarchy
115 neg «base.containmentIndexer.referTransitiveMustContains("source","target")»
116 «ENDIF»
117 } or {
118 «relation.referRelation("source","target",Modality.MUST)»
119 }
120 '''
121 }
122
123 def generateDerivedMustRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''
124 /**
125 * Matcher for detecting tuples t where []«relation.name»(source,target)
126 */
127 private pattern «relation.patternName(Modality.MUST)»(
128 problem:LogicProblem, interpretation:PartialInterpretation,
129 source: DefinedElement, target:DefinedElement)
130 {
131 «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MUST,true,false)»
132 }
133 '''
134 def generateDerivedMayRelation(LogicProblem problem, RelationDeclaration relation, PQuery definition) '''
135 /**
136 * Matcher for detecting tuples t where []«relation.name»(source,target)
137 */
138 private pattern «relation.patternName(Modality.MAY)»(
139 problem:LogicProblem, interpretation:PartialInterpretation,
140 source: DefinedElement, target:DefinedElement)
141 {
142 «base.relationDefinitionIndexer.referPattern(definition,#["source","target"],Modality::MAY,true,false)»
143 }
144 '''
145
146 protected def CharSequence transformTypeConsistency(TypeReference reference, String name) {
147 if(reference instanceof ComplexTypeReference) {
148 this.base.typeIndexer.referInstanceOf(reference.referred,Modality.MAY,name)
149 } else {
150 return '''// Primitive type of «name» is already enforced'''
151 }
152
153 }
154} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
new file mode 100644
index 00000000..7792eccb
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationDefinitionIndexer.xtend
@@ -0,0 +1,185 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition
4import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
5import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransfomedViatraQuery
6import java.util.Map
7import org.eclipse.emf.ecore.EAttribute
8import org.eclipse.emf.ecore.EReference
9import org.eclipse.viatra.query.runtime.emf.types.EClassTransitiveInstancesKey
10import org.eclipse.viatra.query.runtime.emf.types.EStructuralFeatureInstancesKey
11import org.eclipse.viatra.query.runtime.matchers.psystem.PConstraint
12import org.eclipse.viatra.query.runtime.matchers.psystem.PVariable
13import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Equality
14import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.ExportedParameter
15import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.Inequality
16import org.eclipse.viatra.query.runtime.matchers.psystem.basicdeferred.NegativePatternCall
17import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.BinaryTransitiveClosure
18import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.ConstantValue
19import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.PositivePatternCall
20import org.eclipse.viatra.query.runtime.matchers.psystem.basicenumerables.TypeConstraint
21import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
22
23import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
24import org.eclipse.viatra.query.runtime.emf.types.EDataTypeInSlotsKey
25import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
26
27class RelationDefinitionIndexer {
28 val PatternGenerator base;
29
30 new(PatternGenerator base) {
31 this.base = base
32 }
33
34 public def generateRelationDefinitions(
35 LogicProblem problem,
36 Iterable<RelationDefinition> relations,
37 Map<String,PQuery> fqn2PQuery) {
38 val relation2PQuery = relations.toInvertedMap[
39 annotations.filter(TransfomedViatraQuery).head.patternFullyQualifiedName.lookup(fqn2PQuery)
40 ]
41
42 return '''
43 «FOR relation : relations»
44 // Must, May and Current queries for «relation.name»
45 «relation.transformPattern(relation.lookup(relation2PQuery), Modality.MUST)»
46 «relation.transformPattern(relation.lookup(relation2PQuery), Modality.MAY)»
47 «relation.transformPattern(relation.lookup(relation2PQuery), Modality.CURRENT)»
48 «ENDFOR»
49 '''
50 }
51
52 private def relationDefinitionName(RelationDefinition relation, Modality modality)
53 '''«modality.name.toLowerCase»InRelation_«base.canonizeName(relation.name)»'''
54
55 private def canonizeName(PVariable v) {
56 return '''«IF v.referringConstraints.size == 1»_«ENDIF»var_«v.name.replaceAll("\\W","")»'''
57 }
58
59 private def transformPattern(RelationDefinition relation, PQuery p, Modality modality) {
60 try {
61 return '''
62 private pattern «relationDefinitionName(relation,modality)»(
63 problem:LogicProblem, interpretation:PartialInterpretation,
64 «FOR param : p.parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
65 «FOR body : p.disjunctBodies.bodies SEPARATOR "or"»{
66 find interpretation(problem,interpretation);
67 «FOR constraint : body.constraints»
68 «constraint.transformConstraint(modality)»
69 «ENDFOR»
70 }«ENDFOR»
71 '''
72 } catch(UnsupportedOperationException e) {
73 throw new UnsupportedOperationException('''Can not transform pattern "«p.fullyQualifiedName»"!''',e)
74 }
75 }
76
77 private def toMustMay(Modality modality) {
78 if(modality == Modality::MAY) return Modality::MAY
79 else return Modality::MUST
80 }
81
82 def public referPattern(PQuery p, String[] variables, Modality modality, boolean positive, boolean transitive) '''
83 «IF !positive»neg «ENDIF»find «modality.name.toLowerCase»InRelation_pattern_«p.fullyQualifiedName.replace('.','_')»«IF transitive»+«ENDIF»(problem,interpretation,«variables.join(',')»);
84 '''
85
86 private dispatch def transformConstraint(TypeConstraint constraint, Modality modality) {
87 val touple = constraint.variablesTuple
88 if(touple.size == 1) {
89 val inputKey = constraint.equivalentJudgement.inputKey
90 if(inputKey instanceof EClassTransitiveInstancesKey) {
91 return base.typeIndexer.referInstanceOf(inputKey.emfKey,modality.toMustMay,
92 constraint.getVariableInTuple(0).canonizeName)
93 } else if(inputKey instanceof EDataTypeInSlotsKey){
94 return '''// type constraint is enforced by construction'''
95 }
96
97 } else if(touple.size == 2){
98 val key = (constraint.equivalentJudgement.inputKey as EStructuralFeatureInstancesKey).emfKey
99 if(key instanceof EReference) {
100 return base.referRelationByName(
101 key,
102 constraint.getVariableInTuple(0).canonizeName,
103 constraint.getVariableInTuple(1).canonizeName,
104 modality.toMustMay)
105 } else if (key instanceof EAttribute) {
106 return '''// attribute reference omitted'''//base.referRelationByName()
107 } else throw new UnsupportedOperationException('''unknown key: «key.class»''')
108 } else {
109 throw new UnsupportedOperationException()
110 }
111 }
112
113 private dispatch def transformConstraint(Equality equality, Modality modality) {
114 val a = equality.who
115 val b = equality.withWhom
116 transformEquality(modality.toMustMay, a, b)
117 }
118
119 private def CharSequence transformEquality(Modality modality, PVariable a, PVariable b) {
120 if(modality.isMustOrCurrent) '''«a.canonizeName» == «b.canonizeName»;'''
121 else '''find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
122 }
123
124 private dispatch def transformConstraint(Inequality inequality, Modality modality) {
125 val a = inequality.who
126 val b = inequality.withWhom
127 if(modality.isCurrent) {
128 return '''«a.canonizeName» != «b.canonizeName»;'''
129 } else if(modality.isMust) {
130 return '''neg find mayEquivalent(problem, interpretation, «a.canonizeName», «b.canonizeName»);'''
131 } else {
132 return '''«a.canonizeName» != «b.canonizeName»;'''
133 }
134 }
135
136 private dispatch def transformConstraint(NegativePatternCall pcall, Modality modality) {
137 val params = (0..<pcall.actualParametersTuple.size).map[index |
138 val variable = pcall.actualParametersTuple.get(index) as PVariable
139 return variable.canonizeName
140 ]
141 return referPattern(pcall.referredQuery,params,modality.dual,false,false)
142 }
143
144 private dispatch def transformConstraint(PositivePatternCall pcall, Modality modality) {
145 val params = (0..<pcall.variablesTuple.size).map[index |
146 val variable = pcall.variablesTuple.get(index) as PVariable
147 return variable.canonizeName
148 ]
149 return referPattern(pcall.referredQuery,params,modality,true,false)
150 }
151 private dispatch def transformConstraint(BinaryTransitiveClosure pcall, Modality modality) {
152 val params = (0..1).map[index |
153 val variable = pcall.getVariableInTuple(index) as PVariable
154 return variable.canonizeName
155 ]
156 return referPattern(pcall.referredQuery,params,modality,true,true)
157 }
158 private dispatch def transformConstraint(ExportedParameter e, Modality modality) {
159 return '''// «e.parameterName» is exported'''
160 }
161 private dispatch def transformConstraint(ConstantValue c, Modality modality) {
162 val target = c.supplierKey
163
164 var String targetString;
165 var String additionalDefinition;
166 if(target instanceof Enum<?>) {
167 targetString = '''const_«target.name»_«target.declaringClass.simpleName»'''
168 additionalDefinition = '''DefinedElement.name(«targetString»,"«target.name» «target.declaringClass.simpleName»"); LogicProblem.elements(problem,«targetString»);'''
169 } else if(target instanceof Integer) {
170 targetString = target.toString
171 additionalDefinition = ''''''
172 } else throw new UnsupportedOperationException('''Unknown constant type: «target.class»''')
173
174 val source = c.variablesTuple
175 var String sourceName
176 if(source.size == 1)
177 sourceName = (source.get(0) as PVariable).canonizeName
178 else throw new UnsupportedOperationException("unknown source")
179 return '''«sourceName» == «targetString»;«additionalDefinition»''';
180 }
181
182 private dispatch def transformConstraint(PConstraint c, Modality modality) {
183 throw new UnsupportedOperationException('''Unknown constraint type: "«c.class.name»"!''')
184 }
185} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
new file mode 100644
index 00000000..7b175227
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RelationRefinementGenerator.xtend
@@ -0,0 +1,93 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
5import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
6import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
7import java.util.LinkedList
8import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
9
10class RelationRefinementGenerator {
11 PatternGenerator base;
12 public new(PatternGenerator base) {
13 this.base = base
14 }
15
16 def CharSequence generateRefineReference(LogicProblem p) {
17 return '''
18 «FOR relationRefinement: this.getRelationRefinements(p)»
19 pattern «relationRefinementQueryName(relationRefinement.key,relationRefinement.value)»(
20 problem:LogicProblem, interpretation:PartialInterpretation,
21 relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value != null», oppositeInterpretation:PartialRelationInterpretation«ENDIF»,
22 from: DefinedElement, to: DefinedElement)
23 {
24 find interpretation(problem,interpretation);
25 PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
26 PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relationRefinement.key.name»");
27 «IF relationRefinement.value != null»
28 PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);
29 PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"«relationRefinement.value.name»");
30 «ENDIF»
31 find mustExist(problem, interpretation, from);
32 find mustExist(problem, interpretation, to);
33 «base.typeIndexer.referInstanceOf((relationRefinement.key.parameters.get(0) as ComplexTypeReference).referred, Modality::MUST,"from")»
34 «base.typeIndexer.referInstanceOf((relationRefinement.key.parameters.get(1) as ComplexTypeReference).referred, Modality::MUST,"to")»
35 «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MAY)»
36 neg «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MUST)»
37 }
38 «ENDFOR»
39 '''
40 }
41
42 def String relationRefinementQueryName(RelationDeclaration relation, Relation inverseRelation) {
43 '''«IF inverseRelation != null
44 »refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelation.name)»«
45 ELSE
46 »refineRelation_«base.canonizeName(relation.name)»«ENDIF»'''
47 }
48
49 def referRefinementQuery(RelationDeclaration relation, Relation inverseRelation, String relInterpretationName,
50 String inverseInterpretationName, String sourceName, String targetName)
51 '''find «this.relationRefinementQueryName(relation,inverseRelation)»(problem, interpretation, «relInterpretationName», «IF inverseRelation != null»inverseInterpretationName, «ENDIF»«sourceName», «targetName»);'''
52
53 def getRefineRelationQueries(LogicProblem p) {
54// val containmentRelations = p.containmentHierarchies.map[containmentRelations].flatten.toSet
55// p.relations.filter(RelationDeclaration).filter[!containmentRelations.contains(it)].toInvertedMap['''refineRelation_«base.canonizeName(it.name)»''']
56 /*
57 val res = new LinkedHashMap
58 for(relation: getRelationRefinements(p)) {
59 if(inverseRelations.containsKey(relation)) {
60 val name = '''refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelations.get(relation).name)»'''
61 res.put(relation -> inverseRelations.get(relation),name)
62 } else {
63 val name = '''refineRelation_«base.canonizeName(relation.name)»'''
64 res.put(relation -> null,name)
65 }
66 }
67 return res*/
68
69 getRelationRefinements(p).toInvertedMap[relationRefinementQueryName(it.key,it.value)]
70 }
71
72
73 def getRelationRefinements(LogicProblem p) {
74 val inverses = base.getInverseRelations(p)
75 val containments = base.getContainments(p)
76 val list = new LinkedList
77 for(relation : p.relations.filter(RelationDeclaration)) {
78 if(!containments.contains(relation)) {
79 if(inverses.containsKey(relation)) {
80 val inverse = inverses.get(relation)
81 if(!containments.contains(inverse)) {
82 if(base.isRepresentative(relation,inverse)) {
83 list += (relation -> inverse)
84 }
85 }
86 } else {
87 list += (relation -> null)
88 }
89 }
90 }
91 return list
92 }
93} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RepairGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RepairGenerator.xtend
new file mode 100644
index 00000000..30fe5878
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/RepairGenerator.xtend
@@ -0,0 +1,18 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
4
5class RepairGenerator {
6 val PatternGenerator base;
7 new(PatternGenerator base) {
8 this.base = base
9 }
10
11 def generateRepairUnfinishedMultiplicityPatterns(LogicProblem problem) {
12 //val refinements = base.relationRefinementGenerator.getRelationRefinements(problem)
13 //val unfinisedLowerMultiplicities = base.get
14 }
15 def getRepairUnfinishedMultiplicityPatterns() {
16
17 }
18} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
new file mode 100644
index 00000000..6c450664
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexer.xtend
@@ -0,0 +1,16 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
5import org.eclipse.emf.ecore.EClass
6import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
7import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
8import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
9
10interface TypeIndexer {
11 public def CharSequence getRequiredQueries()
12 public def boolean requiresTypeAnalysis()
13 public def CharSequence generateInstanceOfQueries(LogicProblem problem,PartialInterpretation emptySolution,TypeAnalysisResult typeAnalysisResult)
14 public def CharSequence referInstanceOf(Type type, Modality modality, String variableName)
15 public def CharSequence referInstanceOf(EClass type, Modality modality, String variableName)
16} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
new file mode 100644
index 00000000..3c49c323
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeIndexerWithPreliminaryTypeAnalysis.xtend
@@ -0,0 +1,97 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
4import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
5import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
6import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
7import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
8import org.eclipse.emf.ecore.EClass
9import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeRefinementPrecondition
10import java.util.Collections
11
12class TypeIndexerWithPreliminaryTypeAnalysis implements TypeIndexer{
13 val PatternGenerator base;
14
15 new(PatternGenerator base) {
16 this.base = base
17 }
18 override requiresTypeAnalysis() { true }
19
20 override getRequiredQueries() '''
21 private pattern typeInterpretation(problem:LogicProblem, interpetation:PartialInterpretation, type:TypeDeclaration, typeInterpretation:PartialTypeInterpratation) {
22 find interpretation(problem,interpetation);
23 LogicProblem.types(problem,type);
24 PartialInterpretation.partialtypeinterpratation(interpetation,typeInterpretation);
25 PartialTypeInterpratation.interpretationOf(typeInterpretation,type);
26 }
27
28 private pattern directInstanceOf(problem:LogicProblem, interpetation:PartialInterpretation, element:DefinedElement, type:Type) {
29 find interpretation(problem,interpetation);
30 LogicProblem.types(problem,type);
31 TypeDefinition.elements(type,element);
32 } or {
33 find interpretation(problem,interpetation);
34 find typeInterpretation(problem,interpetation,type,typeInterpretation);
35 PartialTypeInterpratation.elements(typeInterpretation,element);
36 }
37 '''
38
39 override generateInstanceOfQueries(LogicProblem problem, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
40 val mayNewTypePreconditions = typeAnalysisResult.mayNewTypePreconditions
41
42 return '''
43 «FOR type:problem.types»
44 «problem.generateMustInstenceOf(type)»
45 «problem.generateMayInstanceOf(type,mayNewTypePreconditions.get(type))»
46 «ENDFOR»
47 '''
48 }
49
50 private def patternName(Type type, Modality modality)
51 '''«modality.toString.toLowerCase»InstanceOf«base.canonizeName(type.name)»'''
52
53 private def generateMustInstenceOf(LogicProblem problem, Type type) {
54 '''
55 /**
56 * An element must be an instance of type "«type.name»".
57 */
58 private pattern «patternName(type,Modality.MUST)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement) {
59 Type.name(type,"«type.name»");
60 find directInstanceOf(problem,interpretation,element,type);
61 }
62 '''
63 }
64
65 private def generateMayInstanceOf(LogicProblem problem, Type type, TypeRefinementPrecondition precondition) {
66 val inhibitorTypes = if(precondition!=null) {
67 precondition.inhibitorTypes
68 } else {
69 null
70 }
71 '''
72 /**
73 * An element may be an instance of type "«type.name»".
74 */
75 private pattern «patternName(type,Modality.MAY)»(problem:LogicProblem, interpretation:PartialInterpretation, element:DefinedElement)
76 «IF inhibitorTypes != null»{
77 find interpretation(problem,interpretation);
78 PartialInterpretation.newElements(interpretation,element);
79 «FOR inhibitorType : inhibitorTypes»
80 neg «referInstanceOf(inhibitorType,Modality.MUST,"element")»
81 «ENDFOR»
82 } or {
83 find interpretation(problem,interpretation);
84 PartialInterpretation.openWorldElementPrototype(interpetation,element);
85 } or
86 «ENDIF»
87 { «referInstanceOf(type,Modality.MUST,"element")» }
88 '''
89 }
90
91 public override referInstanceOf(Type type, Modality modality, String variableName) {
92 '''find «patternName(type,modality)»(problem,interpretation,«variableName»);'''
93 }
94 public override referInstanceOf(EClass type, Modality modality, String variableName) {
95 '''find «modality.toString.toLowerCase»InstanceOf«base.canonizeName('''class «type.name»''')»(problem,interpretation,«variableName»);'''
96 }
97} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend
new file mode 100644
index 00000000..a9ce9d73
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementGenerator.xtend
@@ -0,0 +1,95 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type
5import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
6import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
7import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
8import java.util.Map
9import org.eclipse.xtend.lib.annotations.Data
10import java.util.HashMap
11import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
12import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
13import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
14import java.util.LinkedHashMap
15import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
16import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy
17
18@Data
19class ObjectCreationPrecondition {
20 Relation containmentRelation
21 Relation inverseContainment
22 Type newType
23}
24
25abstract class TypeRefinementGenerator {
26 val protected PatternGenerator base;
27 public new(PatternGenerator base) {
28 this.base = base
29 }
30
31 public def boolean requiresTypeAnalysis()
32 public def CharSequence generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
33 public def CharSequence generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
34 public def Map<? extends Type, String> getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
35
36 public def getRefineObjectQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
37 val Map<ObjectCreationPrecondition,String> objectCreationQueries = new LinkedHashMap
38 val containment = p.containmentHierarchies.head
39 val inverseRelations = new HashMap
40 p.annotations.filter(InverseRelationAssertion).forEach[
41 inverseRelations.put(it.inverseA,it.inverseB)
42 inverseRelations.put(it.inverseB,it.inverseA)
43 ]
44 for(type: p.types.filter(TypeDeclaration).filter[!it.isAbstract]) {
45 if(containment.typeInContainment(type)) {
46 for(containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]) {
47 if(inverseRelations.containsKey(containmentRelation)) {
48 objectCreationQueries.put(
49 new ObjectCreationPrecondition(containmentRelation,inverseRelations.get(containmentRelation),type),
50 this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type))
51 } else {
52 objectCreationQueries.put(
53 new ObjectCreationPrecondition(containmentRelation,null,type),
54 patternName(containmentRelation,null,type))
55 }
56 }
57 } else {
58 objectCreationQueries.put(
59 new ObjectCreationPrecondition(null,null,type),
60 this.patternName(null,null,type))
61 }
62 }
63 return objectCreationQueries
64 }
65
66 protected def canBeContainedByRelation(Relation r, Type t) {
67 if(r.parameters.size==2) {
68 val param = r.parameters.get(1)
69 if(param instanceof ComplexTypeReference) {
70 val allSuperTypes = t.transitiveClosureStar[it.supertypes]
71 for(superType : allSuperTypes) {
72 if(param.referred == superType) return true
73 }
74 }
75 }
76 return false
77 }
78
79 private def typeInContainment(ContainmentHierarchy hierarchy, Type type) {
80 val allSuperTypes = type.transitiveClosureStar[it.supertypes]
81 return allSuperTypes.exists[hierarchy.typesOrderedInHierarchy.contains(it)]
82 }
83
84 protected def String patternName(Relation containmentRelation, Relation inverseContainment, Type newType) {
85 if(containmentRelation != null) {
86 if(inverseContainment != null) {
87 '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»_with_«base.canonizeName(inverseContainment.name)»'''
88 } else {
89 '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»'''
90 }
91 } else {
92 '''createObject_«base.canonizeName(newType.name)»'''
93 }
94 }
95} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend
new file mode 100644
index 00000000..be54d63c
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/TypeRefinementWithPreliminaryTypeAnalysis.xtend
@@ -0,0 +1,105 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
4import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
5import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
6import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
7import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
8import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
9import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
10import java.util.HashMap
11
12class TypeRefinementWithPreliminaryTypeAnalysis extends TypeRefinementGenerator{
13 public new(PatternGenerator base) {
14 super(base)
15 }
16 override requiresTypeAnalysis() { true }
17
18
19 override generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
20 val possibleNewDynamicType = typeAnalysisResult.possibleNewDynamicTypes
21 val containment = p.containmentHierarchies.head
22 val inverseRelations = new HashMap
23 p.annotations.filter(InverseRelationAssertion).forEach[
24 inverseRelations.put(it.inverseA,it.inverseB)
25 inverseRelations.put(it.inverseB,it.inverseA)
26 ]
27 return '''
28 «FOR type:possibleNewDynamicType»
29 «IF(containment.typesOrderedInHierarchy.contains(type))»
30 «FOR containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]»
31 «IF inverseRelations.containsKey(containmentRelation)»
32 pattern «this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)»(
33 problem:LogicProblem, interpretation:PartialInterpretation,
34 relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation, typeInterpretation:PartialTypeInterpratation,
35 container:DefinedElement)
36 {
37 find interpretation(problem,interpretation);
38 PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
39 PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»");
40 PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
41 PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
42 PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation);
43 PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"«inverseRelations.get(containmentRelation).name»");
44 «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
45 «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
46 «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
47 find mustExist(problem, interpretation, container);
48 neg find mustExist(problem, interpretation, newObject);
49 }
50 «ELSE»
51 pattern «this.patternName(containmentRelation,null,type)»(
52 problem:LogicProblem, interpretation:PartialInterpretation,
53 relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialTypeInterpratation,
54 container:DefinedElement)
55 {
56 find interpretation(problem,interpretation);
57 PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
58 PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»");
59 PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
60 PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
61 «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
62 «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
63 «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
64 find mustExist(problem, interpretation, container);
65 neg find mustExist(problem, interpretation, newObject);
66 }
67 «ENDIF»
68 «ENDFOR»
69 «ELSE»
70 pattern createObject_«base.canonizeName(type.name)»(
71 problem:LogicProblem, interpretation:PartialInterpretation,
72 typeInterpretation:PartialTypeInterpratation)
73 {
74 find interpretation(problem,interpretation);
75 PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
76 PartialTypeInterpratation.interpretationOf.name(type,"«type.name»");
77 «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
78 find mayExist(problem, interpretation, newObject);
79 neg find mustExist(problem, interpretation, newObject);
80 }
81 «ENDIF»
82 «ENDFOR»
83 '''
84 }
85
86 override generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
87 val newTypeRefinements = typeAnalysisResult.possibleNewTypeRefinements
88 return '''
89 «FOR newTypeRefinement : newTypeRefinements»
90 pattern refineTypeTo_«base.canonizeName(newTypeRefinement.targetType.name)»(problem:LogicProblem, interpretation:PartialInterpretation, element: DefinedElement) {
91 find interpretation(problem,interpretation);
92 PartialInterpretation.newElements(interpretation,element);
93 «FOR inhibitorType : newTypeRefinement.inhibitorTypes»
94 neg «base.typeIndexer.referInstanceOf(inhibitorType,Modality.MUST,"element")»
95 «ENDFOR»
96 }
97 «ENDFOR»
98 '''
99 }
100
101 override getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
102 val newTypeRefinements = typeAnalysisResult.possibleNewTypeRefinements
103 newTypeRefinements.map[targetType].toInvertedMap['''refineTypeTo_«base.canonizeName(it.name)»''']
104 }
105} \ No newline at end of file
diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
new file mode 100644
index 00000000..ad1c9033
--- /dev/null
+++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra/src/hu/bme/mit/inf/dslreasoner/viatrasolver/logic2viatra/patterns/UnfinishedIndexer.xtend
@@ -0,0 +1,85 @@
1package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
2
3import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.LowerMultiplicityAssertion
4import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
5import hu.bme.mit.inf.dslreasoner.viatra2logic.viatra2logicannotations.TransformedViatraWellformednessConstraint
6import java.util.Map
7import org.eclipse.viatra.query.runtime.matchers.psystem.queries.PQuery
8
9import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
10import java.util.LinkedHashMap
11import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
12import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
13
14class UnfinishedIndexer {
15 val PatternGenerator base
16
17 new(PatternGenerator patternGenerator) {
18 this.base = patternGenerator
19 }
20
21 def generateUnfinishedWfQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {
22 val wfQueries = base.wfQueries(problem)
23 '''
24 «FOR wfQuery: wfQueries»
25 pattern unfinishedBy_«base.canonizeName(wfQuery.target.name)»(problem:LogicProblem, interpretation:PartialInterpretation,
26 «FOR param : wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters SEPARATOR ', '»var_«param.name»«ENDFOR»)
27 {
28 «base.relationDefinitionIndexer.referPattern(
29 wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery),
30 wfQuery.patternFullyQualifiedName.lookup(fqn2PQuery).parameters.map['''var_«it.name»'''],
31 Modality.CURRENT,
32 true,false)»
33 }
34 «ENDFOR»
35 '''
36 }
37 def getUnfinishedWFQueryNames(LogicProblem problem) {
38 val wfQueries = base.wfQueries(problem)
39 val map = new LinkedHashMap
40 for(wfQuery : wfQueries) {
41 map.put(wfQuery.target,'''unfinishedBy_«base.canonizeName(wfQuery.target.name)»''')
42 }
43 return map
44 }
45 def generateUnfinishedMultiplicityQueries(LogicProblem problem, Map<String,PQuery> fqn2PQuery) {
46 val lowerMultiplicities = base.lowerMultiplicities(problem)
47 return '''
48 «FOR lowerMultiplicity : lowerMultiplicities»
49 pattern «unfinishedMultiplicityName(lowerMultiplicity)»(problem:LogicProblem, interpretation:PartialInterpretation, relationIterpretation:PartialRelationInterpretation, object:DefinedElement,missingMultiplicity) {
50 find interpretation(problem,interpretation);
51 PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
52 PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«lowerMultiplicity.relation.name»");
53 «base.typeIndexer.referInstanceOf(lowerMultiplicity.firstParamTypeOfRelation,Modality::MUST,"object")»
54 numberOfExistingReferences == count «base.referRelation(lowerMultiplicity.relation,"object","_",Modality.MUST,fqn2PQuery)»
55 check(numberOfExistingReferences < «lowerMultiplicity.lower»);
56 missingMultiplicity == eval(«lowerMultiplicity.lower»-numberOfExistingReferences);
57 }
58 «ENDFOR»
59 '''
60 }
61 def String unfinishedMultiplicityName(LowerMultiplicityAssertion lowerMultiplicityAssertion)
62 '''unfinishedLowerMultiplicity_«base.canonizeName(lowerMultiplicityAssertion.relation.name)»'''
63
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 }
76
77 def getUnfinishedMultiplicityQueries(LogicProblem problem) {
78 val lowerMultiplicities = base.lowerMultiplicities(problem)
79 val map = new LinkedHashMap
80 for(lowerMultiplicity : lowerMultiplicities) {
81 map.put(lowerMultiplicity.relation,unfinishedMultiplicityName(lowerMultiplicity))
82 }
83 return map
84 }
85}
generated by cgit v1.2.3-54-g00ecf (git 2.45.2) at 2024-06-29 08:42:42 +0000