Newer
Older
package org.etsi.mts.tdl.transform;
import java.util.ArrayList;
import java.util.List;
import java.util.function.Predicate;
import org.eclipse.emf.ecore.EClass;
import org.eclipse.emf.ecore.resource.Resource;
import org.etsi.mts.tdl.Annotation;
import org.etsi.mts.tdl.AnnotationType;
import org.etsi.mts.tdl.Constraint;
import org.etsi.mts.tdl.ConstraintType;
import org.etsi.mts.tdl.DataElementMapping;
import org.etsi.mts.tdl.DataResourceMapping;
import org.etsi.mts.tdl.DataType;
import org.etsi.mts.tdl.Element;
import org.etsi.mts.tdl.ElementImport;
Philip Makedonski
committed
import org.etsi.mts.tdl.EnumDataType;
import org.etsi.mts.tdl.NamedElement;
import org.etsi.mts.tdl.Package;
import org.etsi.mts.tdl.PackageableElement;
import org.etsi.mts.tdl.Parameter;
import org.etsi.mts.tdl.ParameterBinding;
import org.etsi.mts.tdl.ParameterMapping;
import org.etsi.mts.tdl.SimpleDataType;
import org.etsi.mts.tdl.StructuredDataType;
import org.etsi.mts.tdl.tdlFactory;
Philip Makedonski
committed
import org.etsi.mts.tdl.tdlPackage;
public abstract class AbstractTranslator {
protected DataResourceMapping drm;
protected DataResourceMapping drmTarget;
private Package generatedPackage;
protected SimpleDataType stringType;
protected SimpleDataType referencedType;
protected boolean useQualifiers = true;
protected boolean fullPrefix = false;
protected String sourceMappingTag = "SOURCE_MAPPING";
protected String targetMappingTag = "TARGET_MAPPING";
public AbstractTranslator() {
super();
}
public abstract void translate(String targetFilename) throws Exception;
public void initTargetResource(String name) {
generatedPackage = tdlFactory.eINSTANCE.createPackage();
generatedPackage.setName("generated_from_"+name);
targetResource.getContents().add(generatedPackage);
stringType = getSimpleDataTypeFor("String");
referencedType = getSimpleDataTypeFor("TODO_RESOLVE_REFERENCED");
}
public void addImports(Package p) {
generatedPackage.getImport().addAll(p.getImport());
ElementImport sourceImport = tdlFactory.eINSTANCE.createElementImport();
sourceImport.setImportedPackage(p);
generatedPackage.getImport().add(sourceImport);
}
protected DataType getDataTypeFor(String name) {
return getTypeFor(cleanName(name), tdlPackage.Literals.DATA_TYPE);
}
protected SimpleDataType getSimpleDataTypeFor(String name) {
Philip Makedonski
committed
return getTypeFor(cleanName(name), tdlPackage.Literals.SIMPLE_DATA_TYPE);
Philip Makedonski
committed
protected EnumDataType getEnumDataTypeFor(String name) {
return getTypeFor(cleanName(name), tdlPackage.Literals.ENUM_DATA_TYPE);
}
protected StructuredDataType getStructuredDataTypeFor(String name) {
Philip Makedonski
committed
return getTypeFor(cleanName(name), tdlPackage.Literals.STRUCTURED_DATA_TYPE);
public String cleanName(String name) {
// List<String> keywords = List.of("Message", "Time", "Type", "type", "name", "instance", "size", "component");
List<String> keywords = List.of("Message", "Time", "Type", "instance", "size", "component");
name = "^"+name;
}
name = name.replaceAll("-", "_")
.replaceAll(" ", "_")
.replaceAll("\\.", "_");
return name;
}
@SuppressWarnings("unchecked")
protected <T extends PackageableElement> T getTypeFor(String name, EClass targetType) {
String cleanName = cleanName(name);
//TODO: move to ASN2TDL specialisation
TreeMap<String, String> mappings = new TreeMap<>();
mappings.put("AsnInteger", "Integer");
mappings.put("AsnBoolean", "Boolean");
// mappings.put("AsnCharacterString", "String");
mappings.put("AsnOctetString", "OCTETSTRING");
mappings.put("AsnBitString", "BITSTRING");
mappings.put("AsnReal", "Real");
cleanName = mappings.getOrDefault(cleanName, cleanName);
T generatedType = findElementOfType(cleanName, targetType);
if (generatedType == null) {
generatedType = (T) tdlFactory.eINSTANCE.create(targetType);
generatedType.setName(cleanName);
generatedPackage.getPackagedElement().add(generatedType);
}
return generatedType;
}
@SuppressWarnings("unchecked")
protected <T extends PackageableElement> T findElementOfType(String name, EClass targetType) {
Optional<PackageableElement> optional = generatedPackage.getPackagedElement().stream()
.filter(e ->
targetType.isInstance(e) &&
e.getName().equals(cleanName(name)))
.findFirst();
T generatedType = null;
if (optional.isPresent()) {
generatedType = (T) optional.get();
}
return generatedType;
}
@SuppressWarnings("unchecked")
protected <T extends NamedElement> T findContentWithName(String name, NamedElement container, EClass targetType) {
Optional<T> optional = container.eContents().stream()
.filter(e->targetType.isInstance(e))
.map(e->(T) e)
.filter(e -> e.getName().equals(name))
.findFirst();
T content = null;
if (optional.isPresent()) {
content = (T) optional.get();
}
return content;
}
@SuppressWarnings("unchecked")
protected <T extends NamedElement> T getContentWithName(String name, NamedElement container, EClass targetType) {
String cleanName = cleanName(name);
T content = findContentWithName(cleanName, container, targetType);
if (content == null) {
content = (T) tdlFactory.eINSTANCE.create(targetType);
content.setName(cleanName);
}
return content;
}
@SuppressWarnings("unchecked")
protected <T extends Element> Optional<T> getContentWithName(String name, NamedElement container, Class<T> type) {
Optional<T> optional = container.eContents().stream()
.filter(e->type.isInstance(e))
.map(e->(T) e)
.filter(e -> e.getName().equals(name))
.findFirst();
return optional;
}
@SuppressWarnings("unchecked")
protected <T extends Element> Optional<T> getContentWithPredicate(Predicate<? super T> predicate, NamedElement container, Class<T> type) {
Optional<T> optional = container.eContents().stream()
.filter(e->type.isInstance(e))
.map(e->(T) e)
.filter(predicate)
.findFirst();
return optional;
}
protected void annotateWith(final DataType generatedType, String annotationName) {
AnnotationType annotationType = getTypeFor(cleanName(annotationName), tdlPackage.Literals.ANNOTATION_TYPE);
if (!generatedType.getAnnotation().stream().anyMatch(a->a.getKey()==annotationType)) {
Annotation annotation = tdlFactory.eINSTANCE.createAnnotation();
annotation.setKey(annotationType);
generatedType.getAnnotation().add(annotation);
}
}
protected void constrainWith(final DataType generatedType, String constraintName) {
ConstraintType constraintType = getTypeFor(cleanName(constraintName), tdlPackage.Literals.CONSTRAINT_TYPE);
if (!generatedType.getConstraint().stream().anyMatch(a->a.getType()==constraintType)) {
Constraint constraint = tdlFactory.eINSTANCE.createConstraint();
constraint.setType(constraintType);
generatedType.getConstraint().add(constraint);
}
}
protected DataElementMapping addDataElementMapping(String uri, DataType dataType, String tag) {
DataElementMapping mapping = getTypeFor(dataType.getName()+"_"+tag, tdlPackage.Literals.DATA_ELEMENT_MAPPING);
mapping.setMappableDataElement(dataType);
mapping.setElementURI(uri);
mapping.setDataResourceMapping(drm);
return mapping;
}
protected void addParameterMapping(DataElementMapping mapping, Parameter p, String uri) {
Optional<ParameterMapping> opm = getContentWithPredicate(e->e.getParameter() == p, mapping, ParameterMapping.class);
if (opm.isEmpty()) {
ParameterMapping pm = (ParameterMapping) tdlFactory.eINSTANCE.create(tdlPackage.Literals.PARAMETER_MAPPING);
pm.setParameter(p);
pm.setParameterURI(uri.replaceAll("\\^", ""));
mapping.getParameterMapping().add(pm);
}
}
public Resource getTargetResource() {
return targetResource;
}
public void setTargetResource(Resource targetResource) {
this.targetResource = targetResource;
}
public Package getGeneratedPackage() {
return generatedPackage;
}
public void setGeneratedPackage(Package generatedPackage) {
this.generatedPackage = generatedPackage;
}