From a993b72eb3e038897767c79d054467a6986d2085 Mon Sep 17 00:00:00 2001 From: OszkarSemerath Date: Mon, 14 May 2018 12:55:47 +0200 Subject: Moved partial model management is moved to one project (+1 PM edge fix) --- .../InstanceModel2Logic.xtend | 22 +++ .../InstanceModel2PartialInterpretation.xtend | 144 +++++++++++++++++ .../PartialInterpretation2Logic.xtend | 172 +++++++++++++++++++++ .../PartialInterpretationInitialiser.xtend | 7 + 4 files changed, 345 insertions(+) create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend create mode 100644 Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend (limited to 'Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src') diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend new file mode 100644 index 00000000..d2b59754 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2Logic.xtend @@ -0,0 +1,22 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic + +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace +import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem +import java.util.List +import org.eclipse.emf.ecore.EObject +import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes + +class InstanceModel2Logic { + val InstanceModel2PartialInterpretation instanceModel2PartialInterpretation = new InstanceModel2PartialInterpretation + val PartialInterpretation2Logic partialInterpretation2Logic = new PartialInterpretation2Logic + + public def transform( + TracedOutput metamodelTranslationResult, + List objects) + { + val res1 = instanceModel2PartialInterpretation.transform(metamodelTranslationResult,objects,true) + this.partialInterpretation2Logic.transformPartialIntepretation2Logic(metamodelTranslationResult.output,res1) + return metamodelTranslationResult//.output + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend new file mode 100644 index 00000000..9a737ab9 --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/InstanceModel2PartialInterpretation.xtend @@ -0,0 +1,144 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic + +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic +import hu.bme.mit.inf.dslreasoner.ecore2logic.Ecore2Logic_Trace +import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput +import hu.bme.mit.inf.dslreasoner.logic.model.builder.TypeScopes +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory +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.partialinterpretationlanguage.PartialInterpretationInitialiser +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.Problem2PartialInterpretationTrace +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialinterpretationFactory +import java.util.HashMap +import java.util.List +import java.util.Map +import org.eclipse.emf.common.util.Enumerator +import org.eclipse.emf.ecore.EObject +import org.eclipse.emf.ecore.resource.Resource + +import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* + +class InstanceModel2PartialInterpretation { + val extension LogiclanguageFactory factory = LogiclanguageFactory.eINSTANCE + val extension PartialinterpretationFactory factory2 = PartialinterpretationFactory.eINSTANCE + val Ecore2Logic ecore2Logic = new Ecore2Logic + val partialInterpretationInitialiser = new PartialInterpretationInitialiser + + public def transform( + TracedOutput metamodelTranslationResult, + Resource resource, + boolean withID) + { + val objects = resource.allContents.toList + return transform(metamodelTranslationResult,objects,withID) + } + + public def transform( + TracedOutput metamodelTranslationResult, + List objects, + boolean withID) + { + val problem = metamodelTranslationResult.output + val ecore2LogicTrace = metamodelTranslationResult.trace + val tracedOutput = partialInterpretationInitialiser.initialisePartialInterpretation(problem, new TypeScopes) + val partialInterpretation = tracedOutput.output + val partialInterpretationTrace = tracedOutput.trace + + val Map object2DefinedElement = new HashMap + + // EObject -> DefinedElement + for(objectIndex : 0.. [ + it.name = if(withID) + { '''PartialObject«objectIndex»''' } else + { null } + ] + + // Add element to interpretation + partialInterpretation.newElements += element + + // Define the types + val type = ecore2Logic.TypeofEClass(ecore2LogicTrace,object.eClass) as TypeDeclaration + val interpretation = type.lookup(partialInterpretationTrace.type2Interpretation) + interpretation.elements += element + interpretation.supertypeInterpretation.forEach[elements += element] + + // Trace handling + object2DefinedElement.put(object, element) + } + + val referencesUsed = ecore2Logic.allReferencesInScope(ecore2LogicTrace).toSet + val attributesUsed = ecore2Logic.allAttributesInScope(ecore2LogicTrace).toSet + for(source : objects) { + // Translating the references + for(reference : source.eClass.EAllReferences.filter[ + referencesUsed.contains(it) && !it.derived]) + { + val type = ecore2Logic.relationOfReference(ecore2LogicTrace,reference) + val interpretation = type.lookup(partialInterpretationTrace.relation2Interpretation) + val sourceElement = source.lookup(object2DefinedElement) + if(reference.isMany) { + val listOfTargets = source.eGet(reference) as List + for(target : listOfTargets) { + if(target !== null && object2DefinedElement.containsKey(target)) { + val targetElement = target.lookup(object2DefinedElement) + translateLink(interpretation,sourceElement,targetElement) + } + } + } else { + val target = source.eGet(reference) as EObject + if(target !== null && object2DefinedElement.containsKey(target)) { + val targetElement = target.lookup(object2DefinedElement) + translateLink(interpretation,sourceElement,targetElement) + } + } + } + + // Transforming the attributes + for(attribute : source.eClass.EAllAttributes.filter[attributesUsed.contains(it) && !it.derived]) { + val type = ecore2Logic.relationOfAttribute(ecore2LogicTrace,attribute) + val interpretation = type.lookup(partialInterpretationTrace.relation2Interpretation) + val sourceElement = source.lookup(object2DefinedElement) + if(attribute.isMany) { + val listOfTargets = source.eGet(attribute) as List + for(target : listOfTargets) { + val value = translateValue(target,ecore2LogicTrace,partialInterpretationTrace) + if(value !== null) { + translateLink(interpretation,sourceElement,value) + } + } + } else { + val target = source.eGet(attribute) + if(target !== null) { + val value = translateValue(target,ecore2LogicTrace,partialInterpretationTrace) + if(value !== null) { + translateLink(interpretation,sourceElement,value) + } + } + } + } + } + + return partialInterpretation + } + + protected def translateLink(PartialRelationInterpretation interpretation, DefinedElement source, DefinedElement target) { + interpretation.relationlinks += createBinaryElementRelationLink => [it.param1 = source it.param2 = target] + } + + dispatch protected def translateValue(Enumerator value, Ecore2Logic_Trace ecore2LogicTrace, Problem2PartialInterpretationTrace partialInterpretationTrace) { + val term = this.ecore2Logic.Literal(ecore2LogicTrace,value) + if(term instanceof DefinedElement) { + return term + } + else throw new AssertionError('''term should be a defined element?''') + } + + dispatch protected def translateValue(Object value, Ecore2Logic_Trace ecore2LogicTrace, Problem2PartialInterpretationTrace partialInterpretationTrace) { + //throw new UnsupportedOperationException('''Mapping of «value.class.simpleName» in partial models is currently not supported!''') + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend new file mode 100644 index 00000000..3a85536b --- /dev/null +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretation2logic/PartialInterpretation2Logic.xtend @@ -0,0 +1,172 @@ +package hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretation2logic + +import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.LogiclanguageFactory +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.SymbolicDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDeclaration +import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDefinition +import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partial2logicannotations.Partial2logicannotationsFactory +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.BinaryElementRelationLink +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialRelationInterpretation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.PartialTypeInterpratation +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partialinterpretation.RelationLink +import java.util.ArrayList +import java.util.HashMap +import java.util.HashSet +import java.util.Map +import java.util.Set +import org.eclipse.emf.ecore.util.EcoreUtil +import org.eclipse.xtend.lib.annotations.Data + +import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* + +@Data class PartialInterpretation2Logic_Trace { + Map new2Old = new HashMap + + Map definedPart = new HashMap + Map undefinedPart = new HashMap + Set originalTypes = new HashSet + Set splittedTypes = new HashSet +} + +class PartialInterpretation2Logic { + val extension LogiclanguageFactory factory = LogiclanguageFactory.eINSTANCE + val extension LogicProblemBuilder builder = new LogicProblemBuilder + + def transformPartialIntepretation2Logic(LogicProblem p, PartialInterpretation i) { + val trace = new PartialInterpretation2Logic_Trace() + trace.originalTypes.addAll(p.types) + if(! i.newElements.empty) { + + // Elements adding + addExistingElementToProblem(p,i,trace) + + // Types + for(partialTypeDeclaration : i.partialtypeinterpratation) { + splitTypeIntoTwo(p,partialTypeDeclaration,trace) + } + connectSplittings(p,trace) + + // Relations + for(partialRelationInterpretation : i.partialrelationinterpretation) { + //println(partialRelationInterpretation.interpretationOf.name) + relationLinksToAssertion(p,partialRelationInterpretation,trace) + } + } + } + + private def addExistingElementToProblem(LogicProblem p, PartialInterpretation i,PartialInterpretation2Logic_Trace trace) { +// val newElements = new ArrayList(i.newElements) +// var newElementIndex = 1 +// for(newElement : newElements) { +// newElement.name = '''o «newElementIndex++»''' +// p.elements += newElement +// } + p.elements += i.newElements + } + + private def splitTypeIntoTwo(LogicProblem p, PartialTypeInterpratation partialTypeDeclaration,PartialInterpretation2Logic_Trace trace) { + if(!partialTypeDeclaration.elements.empty) { + val declaration = partialTypeDeclaration.interpretationOf + + val definedPart = createTypeDefinition => [ + it.name = '''«declaration.name» DefinedPart''' + it.elements += partialTypeDeclaration.elements + it.isAbstract = declaration.isIsAbstract + ] + val undefinedPart = createTypeDeclaration => [ + it.name = '''«declaration.name» UndefinedPart''' + it.isAbstract = declaration.isIsAbstract + ] + declaration.isAbstract = true + + trace.definedPart.put(declaration,definedPart) + trace.undefinedPart.put(declaration,undefinedPart) + trace.splittedTypes.add(declaration) + p.add(definedPart) + p.add(undefinedPart) + Supertype(definedPart,declaration) + Supertype(undefinedPart,declaration) + + for(containment : p.containmentHierarchies) { + if(containment.typesOrderedInHierarchy.contains(declaration)) { + containment.typesOrderedInHierarchy += definedPart + containment.typesOrderedInHierarchy += undefinedPart + } + } + } + } + + private def connectSplittings(LogicProblem p,PartialInterpretation2Logic_Trace trace) { + val originalTypes = p.types.filter[originalType(trace)].toList + for(type : originalTypes) { + val superTypes = new ArrayList(type.supertypes.filter[originalType(trace)].toList) + for(supertype : superTypes) { + if(type.isSplitted(trace)) { + if(supertype.isSplitted(trace)) { + Supertype((type as TypeDeclaration).lookup(trace.definedPart), (supertype as TypeDeclaration).lookup(trace.definedPart)) + Supertype((type as TypeDeclaration).lookup(trace.undefinedPart), (supertype as TypeDeclaration).lookup(trace.undefinedPart)) + } else { + // Do nothing + } + } else { + if(supertype.isSplitted(trace)) { + Supertype(type, (supertype as TypeDeclaration).lookup(trace.undefinedPart)) + } else if(supertype instanceof TypeDefinition) { + // Do nothing + } + } + } + } + } + + private def originalType(Type type,PartialInterpretation2Logic_Trace trace) { + return trace.originalTypes.contains(type) + } + private def isSplitted(Type t, PartialInterpretation2Logic_Trace trace) { + trace.splittedTypes.contains(t) + } + + private def relationLinksToAssertion(LogicProblem p, PartialRelationInterpretation r,PartialInterpretation2Logic_Trace trace) { + val relation = r.interpretationOf + val links = r.relationlinks + if(links.size == 0) { + // No assertion for empty relations + return + } else { + val term = if(links.size == 1) { + createLink(links.head,relation) + } else { + links.map[link|createLink(link,relation)].And + } + val assertion = Assertion('''PartialInterpretation «r.interpretationOf.name»''',term) + val ^annotation= Partial2logicannotationsFactory.eINSTANCE.createPartialModelRelation2Assertion + ^annotation.target = assertion + ^annotation.targetRelation = relation + ^annotation.links += links.map[EcoreUtil.copy(it)] + //val error= assertion.eAllContents.toIterable.filter(SymbolicValue).filter[it.symbolicReference === null] + //error.forEach[println("error")] + p.add(assertion) + p.annotations+= ^annotation + } + + } + + def private createLink(RelationLink link, SymbolicDeclaration relationDeclaration) { + if(link instanceof BinaryElementRelationLink) { + if((link.param1 !== null) && (link.param2 !== null)) { + return createSymbolicValue=>[ + it.symbolicReference=relationDeclaration + it.parameterSubstitutions += createSymbolicValue => [it.symbolicReference = link.param1] + it.parameterSubstitutions += createSymbolicValue => [it.symbolicReference = link.param2] + ] + } else { + throw new IllegalArgumentException + } + } else throw new UnsupportedOperationException + } +} \ No newline at end of file diff --git a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend index 45fd2c6d..ad9d882b 100644 --- a/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend +++ b/Solvers/VIATRA-Solver/hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage/src/hu/bme/mit/inf/dslreasoner/viatrasolver/partialinterpretationlanguage/PartialInterpretationInitialiser.xtend @@ -27,6 +27,8 @@ import org.eclipse.viatra.query.runtime.emf.EMFScope import org.eclipse.xtend.lib.annotations.Data import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* +import hu.bme.mit.inf.dslreasoner.viatrasolver.partialinterpretationlanguage.partial2logicannotations.PartialModelRelation2Assertion +import org.eclipse.emf.ecore.util.EcoreUtil @Data class Problem2PartialInterpretationTrace { Map type2Interpretation = new HashMap @@ -99,6 +101,11 @@ class PartialInterpretationInitialiser { it.partialrelationinterpretation += problem.relations.filter(RelationDeclaration) .map[initialisePartialRelationInterpretation(trace)] + for(pMR2A : problem.annotations.filter(PartialModelRelation2Assertion)) { + val relation = pMR2A.targetRelation + val interpretation = relation.lookup(trace.relation2Interpretation) + interpretation.relationlinks+=pMR2A.links.map[EcoreUtil.copy(it)] + } it.partialfunctioninterpretation += problem.functions.filter(FunctionDeclaration) .map[initialisePartialFunctionInterpretation(trace)] it.partialconstantinterpretation += problem.constants.filter(ConstantDeclaration) -- cgit v1.2.3-54-g00ecf