From 60f01f46ba232ed6416054f0a6115cb2a9b70b4e Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Sat, 10 Jun 2017 19:05:05 +0200 Subject: Migrating Additional projects --- .../Logic2AlloyLanguageMapper_RelationMapper.xtend | 111 +++++++++++++++++++++ 1 file changed, 111 insertions(+) create mode 100644 Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend (limited to 'Solvers/Alloy-Solver/hu.bme.mit.inf.dlsreasoner.alloy.reasoner/src/hu/bme/mit/inf/dlsreasoner/alloy/reasoner/builder/Logic2AlloyLanguageMapper_RelationMapper.xtend') 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 -- cgit v1.2.3-54-g00ecf