1 files changed, 102 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/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 @@
+package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.HashMap
+class GenericTypeRefinementGenerator extends TypeRefinementGenerator {
+        public new(PatternGenerator base) {
+                super(base)
+        }
+        override requiresTypeAnalysis() { false }
+        
+        override generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+                val containment = p.containmentHierarchies.head
+                val newObjectTypes = p.types.filter(TypeDeclaration).filter[!isAbstract]
+                val inverseRelations = new HashMap
+                p.annotations.filter(InverseRelationAssertion).forEach[
+                        inverseRelations.put(it.inverseA,it.inverseB)
+                        inverseRelations.put(it.inverseB,it.inverseA)
+                ]
+                return '''
+                «FOR type:newObjectTypes»
+                        «IF(containment.typesOrderedInHierarchy.contains(type))»
+                                «FOR containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]»
+                                        «IF inverseRelations.containsKey(containmentRelation)»
+                                                pattern «this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type)»(
+                                                        problem:LogicProblem, interpretation:PartialInterpretation,
+                                                        relationInterpretation:PartialRelationInterpretation, inverseInterpretation:PartialRelationInterpretation ,typeInterpretation:PartialTypeInterpratation,
+                                                        container:DefinedElement)
+                                                {
+                                                        find interpretation(problem,interpretation);
+                                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                                        PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»");
+                                                        PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
+                                                        PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
+                                                        PartialInterpretation.partialrelationinterpretation(interpretation,inverseInterpretation);
+                                                        PartialRelationInterpretation.interpretationOf.name(inverseInterpretation,"«inverseRelations.get(containmentRelation).name»");
+                                                        «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
+                                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                                        «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
+                                                        find mustExist(problem, interpretation, container);
+                                                        neg find mustExist(problem, interpretation, newObject);
+                                                }
+                                        «ELSE»
+                                                pattern «this.patternName(containmentRelation,null,type)»(
+                                                        problem:LogicProblem, interpretation:PartialInterpretation,
+                                                        relationInterpretation:PartialRelationInterpretation, typeInterpretation:PartialTypeInterpratation,
+                                                        container:DefinedElement)
+                                                {
+                                                        find interpretation(problem,interpretation);
+                                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                                        PartialTypeInterpratation.interpretationOf.name(typeInterpretation,"«type.name»");
+                                                        PartialInterpretation.partialrelationinterpretation(interpretation,relationInterpretation);
+                                                        PartialRelationInterpretation.interpretationOf.name(relationInterpretation,"«containmentRelation.name»");
+                                                        «base.typeIndexer.referInstanceOf((containmentRelation.parameters.get(0) as ComplexTypeReference).referred,Modality.MUST,"container")»
+                                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                                        «base.relationDeclarationIndexer.referRelation(containmentRelation as RelationDeclaration,"container","newObject",Modality.MAY)»
+                                                        find mustExist(problem, interpretation, container);
+                                                        neg find mustExist(problem, interpretation, newObject);
+                                                }
+                                        «ENDIF»
+                                «ENDFOR»
+                        «ELSE»
+                                pattern createObject_«this.patternName(null,null,type)»(
+                                        problem:LogicProblem, interpretation:PartialInterpretation,
+                                        typeInterpretation:PartialTypeInterpratation)
+                                {
+                                        find interpretation(problem,interpretation);
+                                        PartialInterpretation.partialtypeinterpratation(interpretation,typeInterpretation);
+                                        PartialTypeInterpratation.interpretationOf.name(type,"«type.name»");
+                                        «base.typeIndexer.referInstanceOf(type,Modality.MAY,"newObject")»
+                                        find mayExist(problem, interpretation, newObject);
+                                        neg find mustExist(problem, interpretation, newObject);
+                                }
+                        «ENDIF»
+                «ENDFOR»
+                '''
+        }
+        override generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+                return '''
+                «FOR type : p.types.filter(TypeDeclaration).filter[!it.isAbstract]»
+                        pattern refineTypeTo_«base.canonizeName(type.name)»(problem:LogicProblem, interpretation:PartialInterpretation, object: DefinedElement) {
+                                find interpretation(problem,interpretation);
+                                find mustExist(problem, interpretation, object);
+                                «base.typeIndexer.referInstanceOf(type,Modality.MAY,"object")»
+                                neg «base.typeIndexer.referInstanceOf(type,Modality.MUST,"object")»
+                        }
+                «ENDFOR»
+                '''
+        }
+        
+        override getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+                p.types.filter(TypeDeclaration).toInvertedMap['''refineTypeTo_«base.canonizeName(it.name)»''']
+        }       
+}
+\ 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 @@
	1	package hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.patterns
	2
	3	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
	4	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
	5	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
	6	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
	7	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
	8	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.Modality
	9	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
	10	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
	11	import java.util.HashMap
	12
	13	class 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