Newer
Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
package org.etsi.mts.tdl.json2tdl;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;
import org.eclipse.xtext.EcoreUtil2;
import org.eclipse.xtext.util.Files;
import org.etsi.mts.tdl.CollectionDataType;
import org.etsi.mts.tdl.DataElementMapping;
import org.etsi.mts.tdl.DataElementUse;
import org.etsi.mts.tdl.DataUse;
import org.etsi.mts.tdl.LiteralValueUse;
import org.etsi.mts.tdl.MappableDataElement;
import org.etsi.mts.tdl.MemberAssignment;
import org.etsi.mts.tdl.NamedElement;
import org.etsi.mts.tdl.Package;
import org.etsi.mts.tdl.Parameter;
import org.etsi.mts.tdl.ParameterBinding;
import org.etsi.mts.tdl.SimpleDataType;
import org.etsi.mts.tdl.StructuredDataInstance;
import org.etsi.mts.tdl.StructuredDataType;
import com.google.gson.Gson;
import com.google.gson.GsonBuilder;
public class TDL2JSONTranslator {
private Map<MappableDataElement, DataElementMapping> dataMappings = new LinkedHashMap<>();
private Map<Parameter, String> parameterMappings = new LinkedHashMap<>();
public void transform(Package p) {
indexMappings(p);
List<StructuredDataInstance> instances = EcoreUtil2.getAllContentsOfType(p, StructuredDataInstance.class);
instances.forEach(this::translate);
}
public void indexMappings(Package p) {
//TODO: assuming mappings are in the same package
//TODO: differentiate mappings
dataMappings = EcoreUtil2.getAllContentsOfType(p, DataElementMapping.class).stream()
.filter(e->e.getName().endsWith("SOURCE_MAPPING"))
.collect(Collectors.toMap(e->e.getMappableDataElement(), e->e));
dataMappings.values().forEach(this::indexParameterMappings);
}
private void indexParameterMappings(DataElementMapping dem) {
dem.getParameterMapping().forEach(pm -> parameterMappings.put(pm.getParameter(), pm.getParameterURI()));
}
public String translate(StructuredDataInstance instance) {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
//DONE: test out basic individual data use translation
//instance.getMemberAssignment().forEach(ma -> translate(ma.getMemberSpec()));
LinkedHashMap<String, Object> map = new LinkedHashMap<>();
instance.getMemberAssignment().forEach(ma -> transform(ma, map));
String json = gson.toJson(map);
//TODO: other primitives not serialised?
//TODO: refine and extract
System.out.println(json);
String prefix = "examples/json/";
String filename = prefix + instance.getQualifiedName().replaceAll("::", "_") + ".json";
Files.writeStringIntoFile(filename , json);
return json;
}
public String translate(DataUse du) {
Gson gson = new GsonBuilder().setPrettyPrinting().create();
String json = gson.toJson(transform(du));
// System.out.println(json);
return json;
}
public Object transform(DataUse du) {
if (du.resolveDataType() instanceof StructuredDataType) {
//TODO: should it apply for function calls and others?
LinkedHashMap<String, Object> map = new LinkedHashMap<>();
du.getArgument().forEach(pb -> transform(pb, map));
//TODO: handle data element if assigned -> structured instance supported, others?
//TODO: also others?
//TODO: handle reduction?
if (du instanceof DataElementUse) {
NamedElement de = ((DataElementUse) du).getDataElement();
if (de instanceof StructuredDataInstance) {
((StructuredDataInstance) de).getMemberAssignment().stream()
.filter(e->du.getArgument().stream()
.noneMatch(a ->a.getParameter() == e.getMember()))
.forEach(ma -> transform(ma, map));
}
}
return map;
} else if (du.resolveDataType() instanceof CollectionDataType) {
if (du instanceof DataElementUse) {
return ((DataElementUse) du).getItem().stream()
.map(this::transform)
.collect(Collectors.toList());
} else {
return null;
}
} else if (du.resolveDataType() instanceof SimpleDataType) {
if (du instanceof LiteralValueUse) {
//TODO: also intValue and boolValue
//TODO: also differentiate during JSON2TDL
LiteralValueUse lvu = ((LiteralValueUse) du);
if (lvu.getIntValue()!=null) {
return lvu.getIntValue();
} else if (lvu.getBoolValue()!=null) {
return lvu.getBoolValue();
}
return lvu.getValue();
} else {
//TODO: handle other data uses
return null;
}
} else {
//TODO: handle other data uses
return null;
}
}
private void transform(ParameterBinding pb, LinkedHashMap<String, Object> map) {
String key = pb.getParameter().getName();
//TODO: handle extensions?
String mappedKey = parameterMappings.get(pb.getParameter());
if (mappedKey != null) {
key = mappedKey;
};
map.put(key, transform(pb.getDataUse()));
}
private void transform(MemberAssignment ma, LinkedHashMap<String, Object> map) {
String key = ma.getMember().getName();
//TODO: handle extensions?
String mappedKey = parameterMappings.get(ma.getMember());
if (mappedKey != null) {
key = mappedKey;
};
map.put(key, transform(ma.getMemberSpec()));
}
}