AbstractTranslator.java

package org.etsi.mts.tdl.transform;

import java.util.ArrayList;
import java.util.List;
import java.util.Optional;
import java.util.TreeMap;
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.DataResourceMapping;
import org.etsi.mts.tdl.DataType;
import org.etsi.mts.tdl.Element;
import org.etsi.mts.tdl.ElementImport;
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.SimpleDataType;
import org.etsi.mts.tdl.StructuredDataType;
import org.etsi.mts.tdl.tdlFactory;
import org.etsi.mts.tdl.tdlPackage;

public abstract class AbstractTranslator {
	protected DataResourceMapping drm;
	protected DataResourceMapping drmTarget;
	private Package generatedPackage;
	protected SimpleDataType stringType;
	private Resource targetResource;
	protected SimpleDataType referencedType;
	protected boolean useQualifiers = true;

	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) {
		return getTypeFor(cleanName(name), tdlPackage.Literals.SIMPLE_DATA_TYPE);
	}

	protected EnumDataType getEnumDataTypeFor(String name) {
		return getTypeFor(cleanName(name), tdlPackage.Literals.ENUM_DATA_TYPE);
	}
	
	protected StructuredDataType getStructuredDataTypeFor(String name) {
		return getTypeFor(cleanName(name), tdlPackage.Literals.STRUCTURED_DATA_TYPE);
	}

	public String cleanName(String name) {
		//TODO: use keywords filter?
		List<String> keywords = List.of("Message", "Time", "Type", "type", "name", "instance", "size", "component"); 
		if (keywords.contains(name)) {
			name = "^"+name;
		}
		name = name.replaceAll("-", "_")
				.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);
		}
	}


	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;
	}

}