+ pulled abstract translator to common

package org.etsi.mts.tdl.transform;

import java.util.Optional;

import java.util.function.Predicate;

import org.eclipse.emf.ecore.EClass;

import org.eclipse.emf.ecore.resource.Resource;

import org.etsi.mts.tdl.Element;

import org.etsi.mts.tdl.ElementImport;

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;

public abstract class AbstractTranslator {

	private Package generatedPackage;

	protected SimpleDataType stringType;

	protected Resource targetResource;

	protected SimpleDataType referencedType;

	protected boolean useQualifiers = true;

	public AbstractTranslator() {

		super();

	}

	protected abstract Resource createTargetResource(String filename);

	@SuppressWarnings("unused")

	private void initTargetResource(String source, Package p) {

		initTargetResource(source, p, "tdlan2");

	}

	protected void initTargetResource(String source, String name, String extension) {

		targetResource = createTargetResource(source+"-data."+extension);

		generatedPackage = tdlFactory.eINSTANCE.createPackage();

		generatedPackage.setName("generated_from_"+name);

		targetResource.getContents().add(generatedPackage);

		stringType = getSimpleDataTypeFor("String");

		referencedType = getSimpleDataTypeFor("TODO_RESOLVE_REFERENCED");

	}

	protected void initTargetResource(String source, Package p, String extension) {

		targetResource = createTargetResource(source+"-data."+extension);

		generatedPackage = tdlFactory.eINSTANCE.createPackage();

		generatedPackage.setName("generated_from_"+p.getName());

		targetResource.getContents().add(generatedPackage);

		generatedPackage.getImport().addAll(p.getImport());

		ElementImport sourceImport = tdlFactory.eINSTANCE.createElementImport();

		sourceImport.setImportedPackage(p);

		generatedPackage.getImport().add(sourceImport);

		stringType = getSimpleDataTypeFor("String");

		referencedType = getSimpleDataTypeFor("TODO_RESOLVE_REFERENCED");

	}

	protected SimpleDataType getSimpleDataTypeFor(String name) {

		String cleanName = cleanName(name);

		Optional<PackageableElement> optional = generatedPackage.getPackagedElement().stream()

			.filter(e -> e instanceof SimpleDataType && e.getName().equals(cleanName))

			.findFirst();

		SimpleDataType generatedType;

		if (optional.isPresent()) {

			generatedType = (SimpleDataType) optional.get();

		} else {

			generatedType = tdlFactory.eINSTANCE.createSimpleDataType();

			generatedType.setName(cleanName);

			generatedPackage.getPackagedElement().add(generatedType);

		}

		return generatedType;

	}

	protected StructuredDataType getStructuredDataTypeFor(String name) {

		String cleanName = cleanName(name);

		Optional<PackageableElement> optional = generatedPackage.getPackagedElement().stream()

			.filter(e -> e instanceof StructuredDataType && e.getName().equals(cleanName))

			.findFirst();

		StructuredDataType generatedType;

		if (optional.isPresent()) {

			generatedType = (StructuredDataType) optional.get();

		} else {

			generatedType = tdlFactory.eINSTANCE.createStructuredDataType();

			generatedType.setName(cleanName);

			generatedPackage.getPackagedElement().add(generatedType);

		}

		return generatedType;

	}

	protected String cleanName(String name) {

		//TODO: use keywords filter?

		if (name.equals("Message") || name.equals("Time") || name.equals("type") || name.equals("name") ) {

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

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

	}

}

 No newline at end of file