1 files changed, 95 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/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 @@
+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.Type
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
+import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
+import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
+import java.util.Map
+import org.eclipse.xtend.lib.annotations.Data
+import java.util.HashMap
+import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
+import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
+import java.util.LinkedHashMap
+import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
+import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy
+@Data
+class ObjectCreationPrecondition {
+        Relation containmentRelation
+        Relation inverseContainment
+        Type newType
+}
+abstract class TypeRefinementGenerator {
+        val protected PatternGenerator base;
+        public new(PatternGenerator base) {
+                this.base = base
+        }
+        
+        public def boolean requiresTypeAnalysis()
+        public def CharSequence generateRefineObjectQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
+        public def CharSequence generateRefineTypeQueries(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
+        public def Map<? extends Type, String> getRefineTypeQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult)
+        
+        public def getRefineObjectQueryNames(LogicProblem p, PartialInterpretation emptySolution, TypeAnalysisResult typeAnalysisResult) {
+                val Map<ObjectCreationPrecondition,String> objectCreationQueries = new LinkedHashMap
+                val containment = p.containmentHierarchies.head
+                val inverseRelations = new HashMap
+                p.annotations.filter(InverseRelationAssertion).forEach[
+                        inverseRelations.put(it.inverseA,it.inverseB)
+                        inverseRelations.put(it.inverseB,it.inverseA)
+                ]
+                for(type: p.types.filter(TypeDeclaration).filter[!it.isAbstract]) {
+                        if(containment.typeInContainment(type)) {
+                                for(containmentRelation : containment.containmentRelations.filter[canBeContainedByRelation(it,type)]) {
+                                        if(inverseRelations.containsKey(containmentRelation)) {
+                                                objectCreationQueries.put(
+                                                        new ObjectCreationPrecondition(containmentRelation,inverseRelations.get(containmentRelation),type),
+                                                        this.patternName(containmentRelation,inverseRelations.get(containmentRelation),type))
+                                        } else {
+                                                objectCreationQueries.put(
+                                                        new ObjectCreationPrecondition(containmentRelation,null,type),
+                                                        patternName(containmentRelation,null,type))
+                                        }
+                                }
+                        } else {
+                                objectCreationQueries.put(
+                                        new ObjectCreationPrecondition(null,null,type),
+                                        this.patternName(null,null,type))
+                        }
+                }
+                return objectCreationQueries
+        }
+        
+        protected def canBeContainedByRelation(Relation r, Type t) {
+                if(r.parameters.size==2) {
+                        val param = r.parameters.get(1)
+                        if(param instanceof ComplexTypeReference) {
+                                val allSuperTypes = t.transitiveClosureStar[it.supertypes]
+                                for(superType : allSuperTypes) {
+                                        if(param.referred == superType) return true
+                                }
+                        }
+                }
+                return false
+        }
+        
+        private def typeInContainment(ContainmentHierarchy hierarchy, Type type) {
+                val allSuperTypes = type.transitiveClosureStar[it.supertypes]
+                return allSuperTypes.exists[hierarchy.typesOrderedInHierarchy.contains(it)]
+        }
+        
+        protected def String patternName(Relation containmentRelation, Relation inverseContainment, Type newType) {
+                if(containmentRelation != null) {
+                        if(inverseContainment != null) {
+                                '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»_with_«base.canonizeName(inverseContainment.name)»'''
+                        } else {
+                                '''createObject_«base.canonizeName(newType.name)»_by_«base.canonizeName(containmentRelation.name)»'''
+                        }
+                } else {
+                        '''createObject_«base.canonizeName(newType.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/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 @@
	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.Type
	5	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem
	6	import hu.bme.mit.inf.dslreasoner.viatrasolver.logic2viatra.TypeAnalysisResult
	7	import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation
	8	import java.util.Map
	9	import org.eclipse.xtend.lib.annotations.Data
	10	import java.util.HashMap
	11	import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.InverseRelationAssertion
	12	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration
	13	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
	14	import java.util.LinkedHashMap
	15	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
	16	import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy
	17
	18	@Data
	19	class ObjectCreationPrecondition {
	20	Relation containmentRelation
	21	Relation inverseContainment
	22	Type newType
	23	}
	24
	25	abstract 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