1 files changed, 93 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/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 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+import java.util.LinkedList
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+class RelationRefinementGenerator {
+        PatternGenerator base;
+        public new(PatternGenerator base) {
+                this.base = base
+        }
+        
+        def CharSequence generateRefineReference(LogicProblem p) {
+                return '''
+                «FOR relationRefinement: this.getRelationRefinements(p)»
+                pattern «relationRefinementQueryName(relationRefinement.key,relationRefinement.value)»(
+                        problem:LogicProblem, interpretation:PartialInterpretation,
+                        relationIterpretation:PartialRelationInterpretation«IF relationRefinement.value != null», oppositeInterpretation:PartialRelationInterpretation«ENDIF»,
+                        from: DefinedElement, to: DefinedElement)
+                {
+                        find interpretation(problem,interpretation);
+                        PartialInterpretation.partialrelationinterpretation(interpretation,relationIterpretation);
+                        PartialRelationInterpretation.interpretationOf.name(relationIterpretation,"«relationRefinement.key.name»");
+                        «IF relationRefinement.value != null»
+                                PartialInterpretation.partialrelationinterpretation(interpretation,oppositeInterpretation);
+                                PartialRelationInterpretation.interpretationOf.name(oppositeInterpretation,"«relationRefinement.value.name»");
+                        «ENDIF»
+                        find mustExist(problem, interpretation, from);
+                        find mustExist(problem, interpretation, to);
+                        «base.typeIndexer.referInstanceOf((relationRefinement.key.parameters.get(0) as ComplexTypeReference).referred, Modality::MUST,"from")»
+                        «base.typeIndexer.referInstanceOf((relationRefinement.key.parameters.get(1) as ComplexTypeReference).referred, Modality::MUST,"to")»
+                        «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MAY)»
+                        neg «base.relationDeclarationIndexer.referRelation(relationRefinement.key,"from","to",Modality.MUST)»
+                }
+                «ENDFOR»
+                '''
+        }
+        
+        def String relationRefinementQueryName(RelationDeclaration relation, Relation inverseRelation) {
+                '''«IF inverseRelation != null
+                »refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelation.name)»«
+                        ELSE
+                »refineRelation_«base.canonizeName(relation.name)»«ENDIF»'''
+        }
+        
+        def referRefinementQuery(RelationDeclaration relation, Relation inverseRelation, String relInterpretationName,
+                String inverseInterpretationName, String sourceName, String targetName)
+        '''find «this.relationRefinementQueryName(relation,inverseRelation)»(problem, interpretation, «relInterpretationName», «IF inverseRelation != null»inverseInterpretationName, «ENDIF»«sourceName», «targetName»);'''
+        
+        def getRefineRelationQueries(LogicProblem p) {
+//              val containmentRelations = p.containmentHierarchies.map[containmentRelations].flatten.toSet
+//              p.relations.filter(RelationDeclaration).filter[!containmentRelations.contains(it)].toInvertedMap['''refineRelation_«base.canonizeName(it.name)»''']
+                /*
+                val res = new LinkedHashMap
+                for(relation: getRelationRefinements(p)) {
+                        if(inverseRelations.containsKey(relation)) {
+                                val name = '''refineRelation_«base.canonizeName(relation.name)»_and_«base.canonizeName(inverseRelations.get(relation).name)»'''
+                                res.put(relation -> inverseRelations.get(relation),name)
+                        } else {
+                                val name = '''refineRelation_«base.canonizeName(relation.name)»'''
+                                res.put(relation -> null,name)
+                        }
+                }
+                return res*/
+                
+                getRelationRefinements(p).toInvertedMap[relationRefinementQueryName(it.key,it.value)]
+        }
+        
+        def getRelationRefinements(LogicProblem p) {
+                val inverses = base.getInverseRelations(p)
+                val containments = base.getContainments(p)
+                val list = new LinkedList
+                for(relation : p.relations.filter(RelationDeclaration)) {
+                        if(!containments.contains(relation)) {
+                                if(inverses.containsKey(relation)) {
+                                        val inverse = inverses.get(relation)
+                                        if(!containments.contains(inverse)) {
+                                                if(base.isRepresentative(relation,inverse)) {
+                                                        list += (relation -> inverse)
+                                                }
+                                        }
+                                } else {
+                                        list += (relation -> null)
+                                }
+                        }
+                }
+                return list
+        }
+}
+\ 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 @@
	1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
	2
	3	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation
	4	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
	5	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
	6	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
	7	import java.util.LinkedList
	8	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
	9
	10	class 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