1 files changed, 111 insertions, 0 deletions
diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend
new file mode 100644
index 00000000..9dd4da2f
--- /dev/null
+++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend
@@ -0,0 +1,111 @@
+package hu.bme.mit.inf.dlsreasoner.alloy.reasoner.builder
+import hu.bme.mit.inf.dslreasoner.alloyLanguage.ALSMultiplicity
+import hu.bme.mit.inf.dslreasoner.alloyLanguage.ALSSignatureBody
+import hu.bme.mit.inf.dslreasoner.alloyLanguage.AlloyLanguageFactory
+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.RelationDefinition
+import java.util.HashMap
+import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
+class Logic2AlloyLanguageMapper_RelationMapper {        
+        private val extension AlloyLanguageFactory factory = AlloyLanguageFactory.eINSTANCE
+        private val Logic2AlloyLanguageMapper_Support support = new Logic2AlloyLanguageMapper_Support;
+        val Logic2AlloyLanguageMapper base;
+        public new(Logic2AlloyLanguageMapper base) {
+                this.base = base
+        }
+                
+        def dispatch protected void  transformRelation(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
+                if(!trace.relationDefinitions.containsKey(r)) {
+                        if(r.transformToHostedField(trace)) {
+                                transformRelationDeclarationToHostedField(r,trace)
+                        } else {
+                                transformRelationDeclarationToGlobalField(r,trace)
+                        }
+                }
+        }
+        
+        def protected transformToHostedField(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
+                val first = r.parameters.get(0)
+                if(r.parameters.size == 2) {
+                        if(first instanceof ComplexTypeReference) {
+                                val types = base.typeMapper.transformTypeReference(first.referred,base,trace)
+                                if(types.size == 1) {
+                                        return true
+                                }
+                        }
+                }
+                return false
+        }
+        
+        def protected transformRelationDeclarationToHostedField(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
+                val hostType = (r.parameters.head as ComplexTypeReference).referred
+                
+                val targetBody = base.typeMapper.transformTypeReference(hostType,base,trace).get(0).eContainer as ALSSignatureBody
+                val field = createALSFieldDeclaration => [
+                        it.name = support.toID(r.getName)
+                        it.multiplicity = ALSMultiplicity.SET
+                        it.type = base.transformTypeReference(r.parameters.get(1),trace)
+                ]
+                targetBody.fields += field
+                trace.relationDeclaration2Field.put(r,field)
+                
+        }
+        
+        def protected transformRelationDeclarationToGlobalField(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
+                val field = createALSFieldDeclaration => [
+                        it.name = support.toID(r.name)
+                        it.type = support.unfoldReferenceDirectProduct(base,r.parameters,trace)
+                ]
+                trace.logicLanguageBody.fields += field
+                trace.relationDeclaration2Global.put(r, field)
+        }
+        def dispatch protected void transformRelation(RelationDefinition r, Logic2AlloyLanguageMapperTrace trace) {
+                val res = createALSRelationDefinition => [
+                        name = support.toID(r.name)
+                        // fill the variables later
+                        // fill the expression later
+                ]
+                
+                trace.relationDefinition2Predicate.put(r,res)
+                trace.specification.relationDefinitions+=res;
+        }
+        
+        def protected void transformRelationDefinitionSpecification(RelationDefinition r, Logic2AlloyLanguageMapperTrace trace) {
+                val predicate = r.lookup(trace.relationDefinition2Predicate)
+                if(predicate !== null) {
+                        val variableMap = new HashMap
+                        for(variable : r.variables) {
+                                val v = createALSVariableDeclaration => [
+                                        it.name = support.toID(variable.name)
+                                        it.range = base.transformTypeReference(variable.range,trace)
+                                ]
+                                predicate.variables+=v
+                                variableMap.put(variable,v)
+                        }
+                        predicate.value = base.transformTerm(r.value,trace,variableMap)
+                }
+        }
+        
+        def public transformRelationReference(RelationDeclaration relation, Logic2AlloyLanguageMapperTrace trace) {
+                if(relation.transformToHostedField(trace)) {
+                        return createALSReference => [it.referred = relation.lookup(trace.relationDeclaration2Field) ]
+                } else {
+                        return createALSJoin => [
+                                leftOperand = createALSReference => [referred = trace.logicLanguage]
+                                rightOperand = createALSReference => [ referred = relation.lookup(trace.relationDeclaration2Global) ]]
+                }
+        }
+        
+        def public getRelationReference(RelationDeclaration relation, Logic2AlloyLanguageMapperTrace trace) {
+                if(relation.transformToHostedField(trace)) {
+                        return relation.lookup(trace.relationDeclaration2Field)
+                } else {
+                        return relation.lookup(trace.relationDeclaration2Global)
+                }
+        }
+}
+\ No newline at end of file

diff --git a/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend new file mode 100644 index 00000000..9dd4da2f --- /dev/null +++ b/Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend
@@ -0,0 +1,111 @@
	1	package hu.bme.mit.inf.dlsreasoner.alloy.reasoner.builder
	2
	3	import hu.bme.mit.inf.dslreasoner.alloyLanguage.ALSMultiplicity
	4	import hu.bme.mit.inf.dslreasoner.alloyLanguage.ALSSignatureBody
	5	import hu.bme.mit.inf.dslreasoner.alloyLanguage.AlloyLanguageFactory
	6	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.ComplexTypeReference
	7	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration
	8	import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDefinition
	9	import java.util.HashMap
	10
	11	import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.*
	12
	13	class Logic2AlloyLanguageMapper_RelationMapper {
	14	private val extension AlloyLanguageFactory factory = AlloyLanguageFactory.eINSTANCE
	15	private val Logic2AlloyLanguageMapper_Support support = new Logic2AlloyLanguageMapper_Support;
	16	val Logic2AlloyLanguageMapper base;
	17	public new(Logic2AlloyLanguageMapper base) {
	18	this.base = base
	19	}
	20
	21	def dispatch protected void transformRelation(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
	22	if(!trace.relationDefinitions.containsKey(r)) {
	23	if(r.transformToHostedField(trace)) {
	24	transformRelationDeclarationToHostedField(r,trace)
	25	} else {
	26	transformRelationDeclarationToGlobalField(r,trace)
	27	}
	28	}
	29	}
	30
	31	def protected transformToHostedField(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
	32	val first = r.parameters.get(0)
	33	if(r.parameters.size == 2) {
	34	if(first instanceof ComplexTypeReference) {
	35	val types = base.typeMapper.transformTypeReference(first.referred,base,trace)
	36	if(types.size == 1) {
	37	return true
	38	}
	39	}
	40	}
	41	return false
	42	}
	43
	44	def protected transformRelationDeclarationToHostedField(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
	45	val hostType = (r.parameters.head as ComplexTypeReference).referred
	46
	47	val targetBody = base.typeMapper.transformTypeReference(hostType,base,trace).get(0).eContainer as ALSSignatureBody
	48	val field = createALSFieldDeclaration => [
	49	it.name = support.toID(r.getName)
	50	it.multiplicity = ALSMultiplicity.SET
	51	it.type = base.transformTypeReference(r.parameters.get(1),trace)
	52	]
	53	targetBody.fields += field
	54	trace.relationDeclaration2Field.put(r,field)
	55
	56	}
	57
	58	def protected transformRelationDeclarationToGlobalField(RelationDeclaration r, Logic2AlloyLanguageMapperTrace trace) {
	59	val field = createALSFieldDeclaration => [
	60	it.name = support.toID(r.name)
	61	it.type = support.unfoldReferenceDirectProduct(base,r.parameters,trace)
	62	]
	63	trace.logicLanguageBody.fields += field
	64	trace.relationDeclaration2Global.put(r, field)
	65	}
	66
	67	def dispatch protected void transformRelation(RelationDefinition r, Logic2AlloyLanguageMapperTrace trace) {
	68	val res = createALSRelationDefinition => [
	69	name = support.toID(r.name)
	70	// fill the variables later
	71	// fill the expression later
	72	]
	73
	74	trace.relationDefinition2Predicate.put(r,res)
	75	trace.specification.relationDefinitions+=res;
	76	}
	77
	78	def protected void transformRelationDefinitionSpecification(RelationDefinition r, Logic2AlloyLanguageMapperTrace trace) {
	79	val predicate = r.lookup(trace.relationDefinition2Predicate)
	80	if(predicate !== null) {
	81	val variableMap = new HashMap
	82	for(variable : r.variables) {
	83	val v = createALSVariableDeclaration => [
	84	it.name = support.toID(variable.name)
	85	it.range = base.transformTypeReference(variable.range,trace)
	86	]
	87	predicate.variables+=v
	88	variableMap.put(variable,v)
	89	}
	90	predicate.value = base.transformTerm(r.value,trace,variableMap)
	91	}
	92	}
	93
	94	def public transformRelationReference(RelationDeclaration relation, Logic2AlloyLanguageMapperTrace trace) {
	95	if(relation.transformToHostedField(trace)) {
	96	return createALSReference => [it.referred = relation.lookup(trace.relationDeclaration2Field) ]
	97	} else {
	98	return createALSJoin => [
	99	leftOperand = createALSReference => [referred = trace.logicLanguage]
	100	rightOperand = createALSReference => [ referred = relation.lookup(trace.relationDeclaration2Global) ]]
	101	}
	102	}
	103
	104	def public getRelationReference(RelationDeclaration relation, Logic2AlloyLanguageMapperTrace trace) {
	105	if(relation.transformToHostedField(trace)) {
	106	return relation.lookup(trace.relationDeclaration2Field)
	107	} else {
	108	return relation.lookup(trace.relationDeclaration2Global)
	109	}
	110	}
	111	} \ No newline at end of file