diff options
author | OszkarSemerath <oszka@152.66.252.189> | 2017-06-10 19:05:05 +0200 |
---|---|---|
committer | OszkarSemerath <oszka@152.66.252.189> | 2017-06-10 19:05:05 +0200 |
commit | 60f01f46ba232ed6416054f0a6115cb2a9b70b4e (patch) | |
tree | 5edf8aeb07abc51f3fec63bbd15c926e1de09552 /Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu | |
parent | Initial commit, migrating from SVN (diff) | |
download | VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.gz VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.tar.zst VIATRA-Generator-60f01f46ba232ed6416054f0a6115cb2a9b70b4e.zip |
Migrating Additional projects
Diffstat (limited to 'Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu')
6 files changed, 617 insertions, 0 deletions
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/AttributeMapper.xtend b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/AttributeMapper.xtend new file mode 100644 index 00000000..ebf49196 --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/AttributeMapper.xtend | |||
@@ -0,0 +1,119 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ecore2logic | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsFactory | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription | ||
9 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TypeDescriptor | ||
10 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
11 | import java.util.HashMap | ||
12 | import java.util.Map | ||
13 | import org.eclipse.emf.ecore.EAttribute | ||
14 | import org.eclipse.emf.ecore.EEnum | ||
15 | |||
16 | interface EAttributeMapper { | ||
17 | def void transformEAttributes(Ecore2Logic_Trace trace, LogicProblem logicProblem, Iterable<EAttribute> attributes) | ||
18 | def Term IsAttributeValue(Ecore2Logic_Trace trace, TermDescription object, TermDescription value, EAttribute attribute) | ||
19 | def RelationDeclaration relationOfAttribute(Ecore2Logic_Trace trace, EAttribute attribute) | ||
20 | def TypeDescriptor TypeOfRange(Ecore2Logic_Trace trace, EAttribute attribute) | ||
21 | } | ||
22 | |||
23 | class EAttributeMapper_RelationsOverTypes_Trace implements Trace<EAttributeMapper_RelationsOverTypes>{ | ||
24 | public var Map<EAttribute, RelationDeclaration> indicators = new HashMap | ||
25 | public var Map<EAttribute, Assertion> typeCompliance = new HashMap | ||
26 | public var Map<EAttribute, Assertion> lowerMultiplicity = new HashMap | ||
27 | public var Map<EAttribute, Assertion> upperMultiplicity = new HashMap | ||
28 | } | ||
29 | |||
30 | class EAttributeMapper_RelationsOverTypes implements EAttributeMapper { | ||
31 | protected val extension LogicProblemBuilder builder = new LogicProblemBuilder | ||
32 | val extension Ecore2logicannotationsFactory builder2 = Ecore2logicannotationsFactory.eINSTANCE | ||
33 | protected val extension EClassMapper classMapper | ||
34 | protected val extension EEnumMapper enumMapper; | ||
35 | |||
36 | public new(EClassMapper classMapper, EEnumMapper enumMapper) { | ||
37 | this.enumMapper = enumMapper | ||
38 | this.classMapper = classMapper | ||
39 | } | ||
40 | |||
41 | public override transformEAttributes(Ecore2Logic_Trace trace, LogicProblem logicProblem, Iterable<EAttribute> attributes) { | ||
42 | val attributeMapperTrace = new EAttributeMapper_RelationsOverTypes_Trace | ||
43 | trace.attributeMapperTrace = attributeMapperTrace | ||
44 | |||
45 | for(attribute : attributes) { | ||
46 | val sourceType = trace.TypeofEClass(attribute.EContainingClass) | ||
47 | val rangeType = trace.TypeOfRange(attribute) | ||
48 | |||
49 | // relations | ||
50 | val indicator = '''inAttribute «attribute.name» «attribute.EContainingClass.name»'''.RelationDeclaration(sourceType,rangeType) | ||
51 | |||
52 | logicProblem.add(indicator) | ||
53 | attributeMapperTrace.indicators.put(attribute,indicator) | ||
54 | |||
55 | // lower multiplicity | ||
56 | var Assertion lowerMultiplicity = null | ||
57 | if(attribute.lowerBound != 0) { | ||
58 | lowerMultiplicity = '''lowerMultiplicity «attribute.name» «attribute.EContainingClass.name»'''.Assertion( | ||
59 | Forall[ | ||
60 | val source = addVar('''src''', sourceType) | ||
61 | Exists[ context | | ||
62 | val targets = (1 .. attribute.lowerBound).map[context.addVar('''trg «it»''', rangeType)].toList | ||
63 | val attributeValue = And(targets.map[IsAttributeValue(trace, source, it, attribute)]) | ||
64 | if(targets.size > 1) return Distinct(targets) && attributeValue | ||
65 | else return attributeValue | ||
66 | ] | ||
67 | ] | ||
68 | ) | ||
69 | val annotation = createLowerMultiplicityAssertion => [ | ||
70 | it.lower = attribute.lowerBound | ||
71 | it.relation = indicator | ||
72 | ] | ||
73 | logicProblem.add(lowerMultiplicity) | ||
74 | logicProblem.annotations += annotation | ||
75 | lowerMultiplicity.annotations +=annotation | ||
76 | } | ||
77 | attributeMapperTrace.lowerMultiplicity.put(attribute,lowerMultiplicity) | ||
78 | |||
79 | var Assertion upperMultiplicity = null | ||
80 | if(attribute.upperBound > 0) { | ||
81 | upperMultiplicity = '''upperMultiplicity «attribute.name» «attribute.EContainingClass.name»'''.Assertion( | ||
82 | Forall[ context | | ||
83 | val source = context.addVar('''src''', sourceType) | ||
84 | val targets = (1 .. attribute.upperBound+1).map[context.addVar('''trg «it»''', rangeType)].toList | ||
85 | And(targets.map[IsAttributeValue(trace, source, it, attribute)]) => ! Distinct(targets) | ||
86 | ]) | ||
87 | |||
88 | val annotation = createUpperMultiplicityAssertion => [ | ||
89 | it.upper = attribute.upperBound | ||
90 | it.relation = indicator | ||
91 | ] | ||
92 | |||
93 | logicProblem.add(upperMultiplicity) | ||
94 | logicProblem.annotations += annotation | ||
95 | upperMultiplicity.annotations += annotation | ||
96 | } | ||
97 | attributeMapperTrace.upperMultiplicity.put(attribute,upperMultiplicity) | ||
98 | } | ||
99 | } | ||
100 | |||
101 | def asTrace(Trace<? extends EAttributeMapper> trace) { return trace as EAttributeMapper_RelationsOverTypes_Trace} | ||
102 | |||
103 | override IsAttributeValue(Ecore2Logic_Trace trace, TermDescription object, TermDescription value, EAttribute attribute) { | ||
104 | trace.attributeMapperTrace.asTrace.indicators.get(attribute).call(object,value) | ||
105 | } | ||
106 | |||
107 | override TypeDescriptor TypeOfRange(Ecore2Logic_Trace trace, EAttribute attribute) { | ||
108 | if(attribute.EType instanceof EEnum) return enumMapper.TypeofEEnum(trace,attribute.EType as EEnum) | ||
109 | else if(attribute.EType.name.equals("EInt")) return LogicInt | ||
110 | else if(attribute.EType.name.equals("EBoolean")) return LogicBool | ||
111 | else if(attribute.EType.name.equals("EDouble") || | ||
112 | attribute.EType.name.equals("EFloat")) return LogicReal | ||
113 | else throw new UnsupportedOperationException('''Unsupported attribute type: «attribute.EType.name»''') | ||
114 | } | ||
115 | |||
116 | override relationOfAttribute(Ecore2Logic_Trace trace, EAttribute attribute) { | ||
117 | trace.attributeMapperTrace.asTrace.indicators.get(attribute) | ||
118 | } | ||
119 | } \ No newline at end of file | ||
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/ContainmentMapper.xtend b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/ContainmentMapper.xtend new file mode 100644 index 00000000..492be59f --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/ContainmentMapper.xtend | |||
@@ -0,0 +1,133 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ecore2logic | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Constant | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Relation | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
7 | import org.eclipse.emf.ecore.EReference | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion | ||
9 | |||
10 | interface ContainmentMapper { | ||
11 | def void transformContainment(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EReference> references, boolean singleRoot); | ||
12 | } | ||
13 | |||
14 | class ContainmentMapper_ReferenceConjuction_Trace implements Trace<ContainmentMapper_ReferenceConjuction> { | ||
15 | public var Constant root; | ||
16 | public var Relation contains | ||
17 | public var Assertion containsDefinition; | ||
18 | public var Assertion rootIsNotContained; | ||
19 | public var Assertion everithingElseContained; | ||
20 | public var Assertion notContainedByMore; | ||
21 | } | ||
22 | |||
23 | class ContainmentMapper_ReferenceConjuction implements ContainmentMapper{ | ||
24 | val extension LogicProblemBuilder builder = new LogicProblemBuilder | ||
25 | val extension EClassMapper classMapper; | ||
26 | val extension EReferenceMapper referenceMapper | ||
27 | val int containmentAcyclicityApproximationLevel; | ||
28 | |||
29 | public new(EClassMapper classMapper, EReferenceMapper referenceMapper, int containmentAcyclicityApproximationLevel) { | ||
30 | this.classMapper = classMapper | ||
31 | this.referenceMapper = referenceMapper | ||
32 | this.containmentAcyclicityApproximationLevel = containmentAcyclicityApproximationLevel | ||
33 | } | ||
34 | |||
35 | override transformContainment(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EReference> references, boolean singleRoot) { | ||
36 | val allClasses = classMapper.allClassesInScope(trace).map[classMapper.TypeofEClass(trace,it)] | ||
37 | val containmentRelation = references.filter[isContainment].map[referenceMapper.relationOfReference(trace,it)] | ||
38 | val containmentHierarchy = ContainmentHierarchy(allClasses,#[],containmentRelation,null) | ||
39 | problem.add(containmentHierarchy) | ||
40 | } | ||
41 | } | ||
42 | |||
43 | /*val containmentMapperTrace = new ContainmentMapper_ReferenceConjuction_Trace | ||
44 | trace.containmentMapperTrace = containmentMapperTrace | ||
45 | |||
46 | val containment = references.filter[containment] | ||
47 | |||
48 | val contains = problem.add(RelationDeclaration('''contains''', getType(trace,references),getType(trace,references))) | ||
49 | containmentMapperTrace.contains = contains | ||
50 | containmentMapperTrace.containsDefinition = problem.add(Assertion('''containsDefinition''', | ||
51 | Forall[ | ||
52 | val parent = addVar("parent",getType(trace,references)) | ||
53 | val child = addVar("child",getType(trace,references)) | ||
54 | contains.call(parent,child) <=> Or(containment.map[IsInReference(trace,parent,child,it)]) | ||
55 | ] | ||
56 | )) | ||
57 | |||
58 | |||
59 | |||
60 | containmentMapperTrace.notContainedByMore = problem.add(Assertion('''notContainedByMore''', | ||
61 | Forall[ | ||
62 | val child = addVar('''child''',getType(trace,references)) | ||
63 | val parent1 = addVar('''parent 1''',getType(trace,references)) | ||
64 | val parent2 = addVar('''parent 2''',getType(trace,references)) | ||
65 | (contains.call(parent1,child) && contains.call(parent2,child)) => (parent1 == parent2) | ||
66 | ] | ||
67 | )) | ||
68 | |||
69 | (2..containmentAcyclicityApproximationLevel).forEach[problem.add(getAcyclicityConstraint(trace,references,it))] | ||
70 | |||
71 | if (singleRoot) { | ||
72 | val root = problem.add(ConstantDeclaration('''root''', getType(trace, references))) | ||
73 | containmentMapperTrace.root = root | ||
74 | |||
75 | containmentMapperTrace.rootIsNotContained = problem.add( | ||
76 | Assertion( | ||
77 | '''rootIsNotContained''', | ||
78 | Forall[ | ||
79 | val parent = addVar("parent", getType(trace, references)) | ||
80 | !contains.call(parent, root) | ||
81 | ] | ||
82 | )) | ||
83 | |||
84 | containmentMapperTrace.everithingElseContained = problem.add( | ||
85 | Assertion( | ||
86 | '''nonrootIsContained''', | ||
87 | Forall[ | ||
88 | val child = addVar("child", getType(trace, references)) | ||
89 | (child != root) => Exists[ | ||
90 | val parent = addVar("parent", getType(trace, references)) | ||
91 | contains.call(parent, child) | ||
92 | ] | ||
93 | ] | ||
94 | )) | ||
95 | }*/ | ||
96 | |||
97 | |||
98 | // def asTrace(Trace<? extends ContainmentMapper> trace) { trace as ContainmentMapper_ReferenceConjuction_Trace } | ||
99 | // | ||
100 | // def getAcyclicityConstraint(Ecore2Logic_Trace trace, Iterable<EReference> references,int circleSize) { | ||
101 | // val newTrace = trace.containmentMapperTrace.asTrace | ||
102 | // //val newTrace2 = trace.containmentMapperTrace as ContainmentMapper_ReferenceConjuction_Trace // ??? | ||
103 | // | ||
104 | // Forall[context | | ||
105 | // val elements = (0..circleSize).map[context.addVar(getType(trace,references))].toList | ||
106 | // !(And((0..circleSize-1).map[newTrace.contains.call(elements.get(it),elements.get(it+1))]) && | ||
107 | // newTrace.contains.call(elements.last,elements.head)) | ||
108 | // ] | ||
109 | // } | ||
110 | // | ||
111 | // def private getType(Ecore2Logic_Trace trace, Iterable<EReference> references) { | ||
112 | // trace.TypeofEClass(references.head.EContainingClass) | ||
113 | // } | ||
114 | |||
115 | /*// This type is contained -> (From this type -> By those references) | ||
116 | val Map<TypeDescriptor,Map<TypeDescriptor,Set<EReference>>> typeContainedBy = new HashMap | ||
117 | for(reference: references.filter[containment]) { | ||
118 | val sourceType = TypeofEClass(classMapperTrace, reference.EContainingClass) | ||
119 | val targetType = TypeofEClass(classMapperTrace, reference.EType as EClass) | ||
120 | if(typeContainedBy.containsKey(targetType)) { | ||
121 | val m = typeContainedBy.get(targetType) | ||
122 | if(m.containsKey(sourceType)) { | ||
123 | m.get(sourceType).add(reference) | ||
124 | } else { | ||
125 | m.put(sourceType,new HashSet => [add(reference)]) | ||
126 | } | ||
127 | } else { // initialise the collection | ||
128 | val Map<TypeDescriptor,Set<EReference>> m = new HashMap | ||
129 | m.put(sourceType,new HashSet => [add(reference)]) | ||
130 | typeContainedBy.put(targetType,m) | ||
131 | } | ||
132 | }*/ | ||
133 | // Only one type \ No newline at end of file | ||
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EClassMapper.xtend b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EClassMapper.xtend new file mode 100644 index 00000000..3949749b --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EClassMapper.xtend | |||
@@ -0,0 +1,53 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ecore2logic | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
6 | import java.util.Map | ||
7 | import org.eclipse.emf.ecore.EClass | ||
8 | import java.util.HashMap | ||
9 | |||
10 | interface EClassMapper { | ||
11 | def void transformEClasses(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EClass> classes, int numberOfObjects, EcoreMetamodelDescriptor metamodelDescriptor) | ||
12 | def Iterable<EClass> allClassesInScope(Ecore2Logic_Trace trace) | ||
13 | def Type TypeofEClass(Ecore2Logic_Trace trace, EClass type) | ||
14 | } | ||
15 | |||
16 | class EClassMapper_AllElementAsObject_Trace implements Trace<EClassMapper_AllElementAsObject>{ | ||
17 | public var Map<EClass, Type> typeMap = new HashMap; | ||
18 | } | ||
19 | |||
20 | class EClassMapper_AllElementAsObject implements EClassMapper{ | ||
21 | val extension LogicProblemBuilder builder = new LogicProblemBuilder | ||
22 | |||
23 | override transformEClasses(Ecore2Logic_Trace trace, LogicProblem problem, | ||
24 | Iterable<EClass> classes, int numberOfObjects, EcoreMetamodelDescriptor metamodelDescriptor | ||
25 | ) { | ||
26 | val classMapperTrace = new EClassMapper_AllElementAsObject_Trace | ||
27 | trace.classMapperTrace = classMapperTrace | ||
28 | for(c:classes) { | ||
29 | val logicType = problem.add(TypeDeclaration('''class «c.name»''',c.isAbstract || c.isInterface)) | ||
30 | classMapperTrace.typeMap.put(c,logicType) | ||
31 | } | ||
32 | for(c:classes) { | ||
33 | for(s : c.ESuperTypes) { | ||
34 | Supertype(classMapperTrace.typeMap.get(c),classMapperTrace.typeMap.get(s)) | ||
35 | } | ||
36 | } | ||
37 | } | ||
38 | |||
39 | def asTrace(Trace<? extends EClassMapper> o) { o as EClassMapper_AllElementAsObject_Trace } | ||
40 | |||
41 | override TypeofEClass(Ecore2Logic_Trace trace, EClass type) { | ||
42 | val typeMap = trace.classMapperTrace.asTrace.typeMap | ||
43 | if(typeMap.containsKey(type)) { | ||
44 | typeMap.get(type) | ||
45 | } else { | ||
46 | throw new IllegalArgumentException('''Class «type.name» is not translated to logic!''') | ||
47 | } | ||
48 | } | ||
49 | |||
50 | override allClassesInScope(Ecore2Logic_Trace trace) { | ||
51 | trace.classMapperTrace.asTrace.typeMap.keySet | ||
52 | } | ||
53 | } | ||
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EEnumMapper.xtend b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EEnumMapper.xtend new file mode 100644 index 00000000..eb7e9e44 --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EEnumMapper.xtend | |||
@@ -0,0 +1,60 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ecore2logic | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.DefinedElement | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Type | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
8 | import java.util.ArrayList | ||
9 | import java.util.HashMap | ||
10 | import java.util.Map | ||
11 | import org.eclipse.emf.common.util.Enumerator | ||
12 | import org.eclipse.emf.ecore.EEnum | ||
13 | |||
14 | import static extension hu.bme.mit.inf.dslreasoner.util.CollectionsUtil.* | ||
15 | |||
16 | interface EEnumMapper { | ||
17 | def void transformEEnums(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EEnum> enums,Ecore2LogicConfiguration config) | ||
18 | def Type TypeofEEnum(Ecore2Logic_Trace trace, EEnum type) | ||
19 | def TermDescription Literal(Ecore2Logic_Trace trace, Enumerator literal) | ||
20 | } | ||
21 | |||
22 | class EEnumMapper_PredefinedClasses_Trace implements Trace<EEnumMapper_PredefinedClasses>{ | ||
23 | public var Map<EEnum, Type> enums | ||
24 | |||
25 | public var Map<Enumerator,DefinedElement> literals | ||
26 | } | ||
27 | |||
28 | class EEnumMapper_PredefinedClasses implements EEnumMapper { | ||
29 | val extension LogicProblemBuilder builder = new LogicProblemBuilder | ||
30 | |||
31 | override transformEEnums(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EEnum> enums, Ecore2LogicConfiguration config) { | ||
32 | val enumTrace = new EEnumMapper_PredefinedClasses_Trace | ||
33 | trace.enumMapperTrace = enumTrace | ||
34 | enumTrace.enums = new HashMap | ||
35 | enumTrace.literals = new HashMap | ||
36 | |||
37 | for(enum : enums) { | ||
38 | val l = new ArrayList<DefinedElement>(enum.ELiterals.size) | ||
39 | for(literal : enum.ELiterals.map[instance]) { | ||
40 | val element = Element('''«literal.name» «enum.name»''') | ||
41 | l+=element | ||
42 | enumTrace.literals.put(literal,element) | ||
43 | } | ||
44 | val type = TypeDefinition('''enum «enum.name»''',false,l) | ||
45 | problem.add(type) | ||
46 | enumTrace.enums.put(enum,type) | ||
47 | } | ||
48 | |||
49 | } | ||
50 | |||
51 | private def asTrace(Trace<? extends EEnumMapper> o) { o as EEnumMapper_PredefinedClasses_Trace } | ||
52 | |||
53 | override TypeofEEnum(Ecore2Logic_Trace trace, EEnum type) { | ||
54 | trace.enumMapperTrace.asTrace.enums.get(type) | ||
55 | } | ||
56 | |||
57 | override Literal(Ecore2Logic_Trace trace, Enumerator literal) { | ||
58 | literal.lookup(trace.enumMapperTrace.asTrace.literals) | ||
59 | } | ||
60 | } \ No newline at end of file | ||
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EReferenceMapper.xtend b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EReferenceMapper.xtend new file mode 100644 index 00000000..e5de6584 --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/EReferenceMapper.xtend | |||
@@ -0,0 +1,154 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ecore2logic | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.ecore2logic.ecore2logicannotations.Ecore2logicannotationsFactory | ||
4 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder | ||
5 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Assertion | ||
6 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.RelationDeclaration | ||
7 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.Term | ||
8 | import hu.bme.mit.inf.dslreasoner.logic.model.logiclanguage.TermDescription | ||
9 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
10 | import java.util.HashMap | ||
11 | import java.util.Map | ||
12 | import org.eclipse.emf.ecore.EClass | ||
13 | import org.eclipse.emf.ecore.EReference | ||
14 | |||
15 | interface EReferenceMapper{ | ||
16 | def void transformEReferences(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EReference> classes); | ||
17 | def Term IsInReference(Ecore2Logic_Trace trace, TermDescription source, TermDescription target, EReference type) | ||
18 | def RelationDeclaration relationOfReference(Ecore2Logic_Trace trace, EReference reference) | ||
19 | } | ||
20 | |||
21 | class EReferenceMapper_RelationsOverTypes_Trace implements Trace<EReferenceMapper_RelationsOverTypes> { | ||
22 | public var Map<EReference, RelationDeclaration> indicators; | ||
23 | public var Map<EReference, Assertion> typeCompliance | ||
24 | public var Map<EReference, Assertion> lowerMultiplicity | ||
25 | public var Map<EReference, Assertion> upperMultiplicity | ||
26 | public var Map<EReference, Assertion> inverseEdges | ||
27 | } | ||
28 | |||
29 | class EReferenceMapper_RelationsOverTypes implements EReferenceMapper{ | ||
30 | val extension LogicProblemBuilder builder = new LogicProblemBuilder | ||
31 | val extension Ecore2logicannotationsFactory builder2 = Ecore2logicannotationsFactory.eINSTANCE | ||
32 | val extension EClassMapper classMapper; | ||
33 | |||
34 | public new(EClassMapper classMapper) { | ||
35 | this.classMapper = classMapper | ||
36 | } | ||
37 | |||
38 | def asTrace(Trace<? extends EReferenceMapper> o) { o as EReferenceMapper_RelationsOverTypes_Trace } | ||
39 | |||
40 | override transformEReferences(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EReference> references) { | ||
41 | val newTrace = new EReferenceMapper_RelationsOverTypes_Trace | ||
42 | trace.referenceMapperTrace = newTrace | ||
43 | trace.createIndicatorDeclarations(problem,references) | ||
44 | trace.createMultiplicityConstraints(problem,references) | ||
45 | trace.createInverseReferenceConstraints(problem,references) | ||
46 | } | ||
47 | |||
48 | def protected void createIndicatorDeclarations(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EReference> references) { | ||
49 | trace.referenceMapperTrace.asTrace.indicators = new HashMap | ||
50 | for(reference : references) { | ||
51 | val relation = problem.add(RelationDeclaration( | ||
52 | '''inreference «reference.name» «reference.EContainingClass.name»''', | ||
53 | TypeofEClass(trace,reference.EContainingClass), | ||
54 | TypeofEClass(trace,reference.EType as EClass))) | ||
55 | trace.referenceMapperTrace.asTrace.indicators.put(reference,relation as RelationDeclaration) | ||
56 | } | ||
57 | } | ||
58 | |||
59 | def void createMultiplicityConstraints(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EReference> references) { | ||
60 | trace.referenceMapperTrace.asTrace.lowerMultiplicity = new HashMap | ||
61 | trace.referenceMapperTrace.asTrace.upperMultiplicity = new HashMap | ||
62 | |||
63 | for(reference : references) { | ||
64 | val sourceType = reference.EContainingClass | ||
65 | val targetType = reference.EType as EClass | ||
66 | val lower = reference.lowerBound | ||
67 | val upper = reference.upperBound | ||
68 | |||
69 | if (lower > 0) { | ||
70 | val assertion = Assertion('''lowerMultiplicity «reference.name» «sourceType.name»''', | ||
71 | Forall[ | ||
72 | val source = addVar('''src''', trace.TypeofEClass(sourceType)) | ||
73 | Exists[ context | | ||
74 | val targets = (1 .. lower).map[ | ||
75 | context.addVar('''trg «it»''', trace.TypeofEClass(targetType))].toList | ||
76 | val inReference = And(targets.map[IsInReference(trace, source, it, reference)]) | ||
77 | if(targets.size > 1) return Distinct(targets) && inReference | ||
78 | else return inReference | ||
79 | ] | ||
80 | ] | ||
81 | ) | ||
82 | val annotation = createLowerMultiplicityAssertion => [ | ||
83 | it.lower = lower | ||
84 | it.relation = trace.referenceMapperTrace.asTrace.indicators.get(reference) | ||
85 | ] | ||
86 | |||
87 | problem.add(assertion) | ||
88 | problem.annotations += annotation | ||
89 | assertion.annotations +=annotation | ||
90 | trace.referenceMapperTrace.asTrace.lowerMultiplicity.put(reference,assertion) | ||
91 | } | ||
92 | else trace.referenceMapperTrace.asTrace.lowerMultiplicity.put(reference,null) | ||
93 | |||
94 | if(upper != -1) { | ||
95 | val assertion = Assertion('''upperMultiplicity «reference.name» «sourceType.name»''', | ||
96 | Forall[ context | | ||
97 | val source = context.addVar('''src''', trace.TypeofEClass(sourceType)) | ||
98 | val targets = (1 .. upper+1).map[ | ||
99 | context.addVar('''trg «it»''', trace.TypeofEClass(targetType))].toList | ||
100 | And(targets.map[IsInReference(trace, source, it, reference)]) => ! Distinct(targets) | ||
101 | ]) | ||
102 | val annotation = createUpperMultiplicityAssertion => [ | ||
103 | it.upper = upper | ||
104 | it.relation = trace.referenceMapperTrace.asTrace.indicators.get(reference) | ||
105 | ] | ||
106 | |||
107 | problem.add(assertion) | ||
108 | problem.annotations += annotation | ||
109 | assertion.annotations += annotation | ||
110 | trace.referenceMapperTrace.asTrace.lowerMultiplicity.put(reference,assertion) | ||
111 | } | ||
112 | else trace.referenceMapperTrace.asTrace.upperMultiplicity.put(reference,null) | ||
113 | } | ||
114 | } | ||
115 | |||
116 | def createInverseReferenceConstraints(Ecore2Logic_Trace trace, LogicProblem problem, Iterable<EReference> references) { | ||
117 | trace.referenceMapperTrace.asTrace.inverseEdges = new HashMap | ||
118 | for(reference : references) { | ||
119 | if(reference.EOpposite!=null) { | ||
120 | val opposite = reference.EOpposite | ||
121 | if(trace.referenceMapperTrace.asTrace.inverseEdges.containsKey(opposite)) { | ||
122 | trace.referenceMapperTrace.asTrace.inverseEdges.put(reference,trace.referenceMapperTrace.asTrace.inverseEdges.get(opposite)) | ||
123 | } else { | ||
124 | val sourceType = reference.EContainingClass | ||
125 | val targetType = reference.EType as EClass | ||
126 | val assertion = Assertion('''oppositeReference «reference.name» «sourceType.name»''', | ||
127 | Forall[ | ||
128 | val src = addVar('''src''', trace.TypeofEClass(sourceType)) | ||
129 | val trg = addVar('''trg''', trace.TypeofEClass(targetType)) | ||
130 | IsInReference(trace,src,trg,reference) <=> IsInReference(trace,trg,src,opposite) | ||
131 | ] | ||
132 | ) | ||
133 | problem.add(assertion) | ||
134 | trace.referenceMapperTrace.asTrace.inverseEdges.put(reference,assertion) | ||
135 | val annotation = createInverseRelationAssertion => [ | ||
136 | it.target = assertion | ||
137 | it.inverseA = trace.referenceMapperTrace.asTrace.indicators.get(reference) | ||
138 | it.inverseB = trace.referenceMapperTrace.asTrace.indicators.get(reference.EOpposite) | ||
139 | ] | ||
140 | problem.annotations += annotation | ||
141 | } | ||
142 | } | ||
143 | else trace.referenceMapperTrace.asTrace.inverseEdges.put(reference,null) | ||
144 | } | ||
145 | } | ||
146 | |||
147 | override IsInReference(Ecore2Logic_Trace trace, TermDescription source, TermDescription target, EReference type) { | ||
148 | trace.referenceMapperTrace.asTrace.indicators.get(type).call(source,target) | ||
149 | } | ||
150 | |||
151 | override relationOfReference(Ecore2Logic_Trace trace, EReference reference) { | ||
152 | trace.referenceMapperTrace.asTrace.indicators.get(reference) | ||
153 | } | ||
154 | } \ No newline at end of file | ||
diff --git a/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/Ecore2Logic.xtend b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/Ecore2Logic.xtend new file mode 100644 index 00000000..cae489e3 --- /dev/null +++ b/Framework/hu.bme.mit.inf.dslreasoner.ecore2logic/src/hu/bme/mit/inf/dslreasoner/ecore2logic/Ecore2Logic.xtend | |||
@@ -0,0 +1,98 @@ | |||
1 | package hu.bme.mit.inf.dslreasoner.ecore2logic | ||
2 | |||
3 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.LogicProblem | ||
4 | import java.util.List | ||
5 | import org.eclipse.emf.ecore.EAttribute | ||
6 | import org.eclipse.emf.ecore.EClass | ||
7 | import org.eclipse.emf.ecore.EEnum | ||
8 | import org.eclipse.emf.ecore.EEnumLiteral | ||
9 | import org.eclipse.emf.ecore.EReference | ||
10 | import org.eclipse.xtend.lib.annotations.Data | ||
11 | import org.eclipse.xtend.lib.annotations.Delegate | ||
12 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.TracedOutput | ||
13 | import hu.bme.mit.inf.dslreasoner.logic.model.builder.LogicProblemBuilder | ||
14 | import java.util.Set | ||
15 | import hu.bme.mit.inf.dslreasoner.logic.model.logicproblem.ContainmentHierarchy | ||
16 | |||
17 | @Data class EcoreMetamodelDescriptor { | ||
18 | val List<EClass> classes; | ||
19 | val Set<EClass> concretised; | ||
20 | val boolean isEObjectConcretised; | ||
21 | val List<EEnum> enums; | ||
22 | val List<EEnumLiteral> literals; | ||
23 | val List<EReference> references; | ||
24 | val List<EAttribute> attributes; | ||
25 | |||
26 | def isConcretised(EClass clazz) {concretised.contains(clazz)} | ||
27 | } | ||
28 | |||
29 | interface Trace<Mapper> {} | ||
30 | |||
31 | class Ecore2Logic_Trace implements Trace<Ecore2Logic> { | ||
32 | public var ContainmentHierarchy containmentHierarchy; | ||
33 | public var Trace<? extends EClassMapper> classMapperTrace | ||
34 | public var Trace<? extends EEnumMapper> enumMapperTrace | ||
35 | public var Trace<? extends EReferenceMapper> referenceMapperTrace | ||
36 | public var Trace<? extends ContainmentMapper> containmentMapperTrace | ||
37 | public var Trace<? extends EAttributeMapper> attributeMapperTrace | ||
38 | } | ||
39 | |||
40 | class Ecore2LogicConfiguration { | ||
41 | var public boolean singleRoot = true | ||
42 | var public int numberOfObjects = -1 | ||
43 | public static val Undefined = -1 | ||
44 | } | ||
45 | |||
46 | class Ecore2LogicScope { | ||
47 | public static val int Unlimited = -1 | ||
48 | public var numberOfObjects = Unlimited | ||
49 | } | ||
50 | |||
51 | class Ecore2Logic implements EClassMapper, EEnumMapper, EReferenceMapper, ContainmentMapper, EAttributeMapper { | ||
52 | @Delegate protected val EClassMapper classMapper | ||
53 | @Delegate protected val EEnumMapper enumMapper | ||
54 | @Delegate protected val EReferenceMapper referenceMapper | ||
55 | @Delegate protected val ContainmentMapper containmentMapper | ||
56 | @Delegate protected val EAttributeMapper attributeMapper | ||
57 | |||
58 | public new() { | ||
59 | this.classMapper = new EClassMapper_AllElementAsObject | ||
60 | this.enumMapper = new EEnumMapper_PredefinedClasses | ||
61 | this.referenceMapper = new EReferenceMapper_RelationsOverTypes(this.classMapper) | ||
62 | this.containmentMapper = new ContainmentMapper_ReferenceConjuction(this.classMapper, this.referenceMapper,0) | ||
63 | this.attributeMapper = new EAttributeMapper_RelationsOverTypes(this.classMapper, this.enumMapper) | ||
64 | } | ||
65 | |||
66 | public new( | ||
67 | EClassMapper classMapper, | ||
68 | EEnumMapper enumMapper, | ||
69 | EReferenceMapper referenceMapper, | ||
70 | ContainmentMapper containmentMapper, | ||
71 | EAttributeMapper attributeMapper) | ||
72 | { | ||
73 | if(classMapper === null || enumMapper === null || referenceMapper === null || containmentMapper === null || | ||
74 | attributeMapper === null) { | ||
75 | throw new IllegalArgumentException('''The mappers should not be null!''') | ||
76 | } | ||
77 | |||
78 | this.classMapper = classMapper | ||
79 | this.enumMapper = enumMapper | ||
80 | this.referenceMapper = referenceMapper | ||
81 | this.containmentMapper = containmentMapper | ||
82 | this.attributeMapper = attributeMapper | ||
83 | } | ||
84 | |||
85 | def public TracedOutput<LogicProblem,Ecore2Logic_Trace> transformMetamodel(EcoreMetamodelDescriptor metamodel, Ecore2LogicConfiguration config) { | ||
86 | |||
87 | |||
88 | val Ecore2Logic_Trace trace = new Ecore2Logic_Trace | ||
89 | val LogicProblem problem = (new LogicProblemBuilder).createProblem | ||
90 | transformEClasses(trace,problem,metamodel.classes,config.numberOfObjects,metamodel) | ||
91 | transformEEnums(trace,problem,metamodel.enums,config) | ||
92 | transformEReferences(trace,problem,metamodel.references) | ||
93 | transformContainment(trace,problem,metamodel.references, config.singleRoot) | ||
94 | transformEAttributes(trace,problem,metamodel.attributes) | ||
95 | |||
96 | return new TracedOutput(problem,trace) | ||
97 | } | ||
98 | } | ||