org.eclipse.emf.refactor.comrel/src/comrel/util/RegistryUtil.java

package comrel.util;

import java.util.Collection;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.TreeSet;

import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.refactor.refactoring.core.Refactoring;
import org.eclipse.emf.refactor.refactoring.managers.RefactoringManager;

import comrel.ComrelFactory;
import comrel.Helper;
import comrel.ModelRefactoring;
import comrel.MultiFeatureHelper;
import comrel.MultiFilterHelper;
import comrel.MultiInputPort;
import comrel.MultiOutputPort;
import comrel.Port;
import comrel.SingleFeatureHelper;
import comrel.SingleFilterHelper;
import comrel.SingleInputPort;
import comrel.SingleOutputPort;
import comrel.extensions.IMultiFeatureHelper;
import comrel.extensions.IMultiFilterHelper;
import comrel.extensions.ISingleFeatureHelper;
import comrel.extensions.ISingleFilterHelper;

public class RegistryUtil {
//	private static final String SINGLEFILTER_EXTENSION_POINT = "org.eclipse.emf.refactor.singlefilter";
//	private static final String MULTIFILTER_EXTENSION_POINT = "org.eclipse.emf.refactor.multifilter";
//	private static final String SINGLEFEATURE_EXTENSION_POINT = "org.eclipse.emf.refactor.singlefeature";
//	private static final String MULTIFEATURE_EXTENSION_POINT = "org.eclipse.emf.refactor.multifeature";
//
//	private static final String SINGLEFEATURE_SEARCH_STRING = "singlefeature";
//	private static final String MULTIFEATURE_SEARCH_STRING = "multifeature";
//	private static final String SINGLEFILTER_SEARCH_STRING = "singlefilter";
//	private static final String MULTIFILTER_SEARCH_STRING = "multifilter";

	/**
	 * lädt die Helper, gefiltert nach der namespaceUri
	 * 
	 * @param namespaceURI
	 *            nach der gefiltert werden soll
	 * @return Set der gefilterten Helper
	 */
	public static Set<SingleFilterHelper> loadSingleFilterHelper(
			String namespaceURI) {
		Set<SingleFilterHelper> result = new HashSet<SingleFilterHelper>();
		for (SingleFilterHelper h : loadSingleFilterHelper()) {
			if (h.getNamespaceUri().equals(namespaceURI)) {
				result.add(h);
			}
		}
		return result;
	}

	/**
	 * lädt die Helper
	 * 
	 * @return Set der Helper
	 */
	public static Set<SingleFilterHelper> loadSingleFilterHelper() {
		return castSet(loadHelper(ExtensionPointInfo.SINGLEFILTER_EXTENSION_POINT));
	}

	/**
	 * lädt die Helper, gefiltert nach der namespaceUri
	 * 
	 * @param namespaceURI
	 *            nach der gefiltert werden soll
	 * @return Set der gefilterten Helper
	 */
	public static Set<MultiFilterHelper> loadMultiFilterHelper(
			String namespaceURI) {
		Set<MultiFilterHelper> result = new HashSet<MultiFilterHelper>();
		for (MultiFilterHelper h : loadMultiFilterHelper()) {
			if (h.getNamespaceUri().equals(namespaceURI)) {
				result.add(h);
			}
		}
		return result;
	}

	/**
	 * lädt die Helper
	 * 
	 * @return Set der Helper
	 */
	public static Set<MultiFilterHelper> loadMultiFilterHelper() {
		return castSet(loadHelper(ExtensionPointInfo.MULTIFILTER_EXTENSION_POINT));
	}

	/**
	 * lädt die Helper, gefiltert nach der namespaceUri
	 * 
	 * @param namespaceURI
	 *            nach der gefiltert werden soll
	 * @return Set der gefilterten Helper
	 */
	public static Set<SingleFeatureHelper> loadSingleFeatureHelper(
			String namespaceURI) {
		Set<SingleFeatureHelper> result = new HashSet<SingleFeatureHelper>();
		for (SingleFeatureHelper h : loadSingleFeatureHelper()) {
			if (h.getNamespaceUri().equals(namespaceURI)) {
				result.add(h);
			}
		}
		return result;
	}

	/**
	 * lädt die Helper
	 * 
	 * @return Set der Helper
	 */
	public static Set<SingleFeatureHelper> loadSingleFeatureHelper() {
		return castSet(loadHelper(ExtensionPointInfo.SINGLEFEATURE_EXTENSION_POINT));
	}

	/**
	 * lädt die Helper, gefiltert nach der namespaceUri
	 * 
	 * @param namespaceURI
	 *            nach der gefiltert werden soll
	 * @return Set der gefilterten Helper
	 */
	public static Set<MultiFeatureHelper> loadMultiFeatureHelper(
			String namespaceURI) {
		Set<MultiFeatureHelper> result = new HashSet<MultiFeatureHelper>();
		for (MultiFeatureHelper h : loadMultiFeatureHelper()) {
			if (h.getNamespaceUri().equals(namespaceURI)) {
				result.add(h);
			}
		}
		return result;
	}

	/**
	 * lädt die Helper
	 * 
	 * @return Set der Helper
	 */
	public static Set<MultiFeatureHelper> loadMultiFeatureHelper() {
		return castSet(loadHelper(ExtensionPointInfo.MULTIFEATURE_EXTENSION_POINT));
	}

	/**
	 * Lädt anhand des Extension Points die entsprechenden Helper
	 * 
	 * @param extensionPoint
	 *            zu durchszuchender Extension Point
	 * @return Helper
	 */
	private static Set<Helper> loadHelper(String extensionPoint) {
		Set<Helper> result = new HashSet<Helper>();
		IConfigurationElement[] helper = Platform.getExtensionRegistry()
				.getConfigurationElementsFor(extensionPoint);
		for (IConfigurationElement e : helper) {
			try {

				Helper h = createHelper(e);
				if (null != h)
					result.add(h);

			} catch (Exception e2) {
				e2.printStackTrace();
			}
		}
		return result;
	}

	/**
	 * Erstellt anhand des e-Elementes den entsprechenden Helper
	 * 
	 * @param e
	 *            IConfigurableElement
	 * @return Helper
	 */
	private static Helper createHelper(IConfigurationElement e) {
		if (e.getName().equals(ExtensionPointInfo.SINGLEFEATURE)) {
			return createSingleFeatureHelper(e);
		}
		if (e.getName().equals(ExtensionPointInfo.MULTIFEATURE)) {
			return createMultiFeatureHelper(e);
		}
		if (e.getName().equals(ExtensionPointInfo.SINGLEFILTER)) {
			return createSingleFilterHelper(e);
		}
		if (e.getName().equals(ExtensionPointInfo.MULTIFILTER)) {
			return createMultiFilterHelper(e);
		}
		return null;
	}

	/**
	 * Casted ein Set
	 * 
	 * @param <E>
	 * @param set
	 * @return
	 */
	@SuppressWarnings({ "unchecked", "rawtypes" })
	private static <E> Set<E> castSet(Set set) {
		Set<E> result = new HashSet<E>();
		for (Object o : set) {
			try {
				result.add((E) o);
			} catch (Exception e) {
			}
		}
		return result;
	}

	/**
	 * Erstellt einen Helper
	 * 
	 * @param e
	 *            IConfigurableElement
	 * @return Helper
	 */
	private static SingleFilterHelper createSingleFilterHelper(
			IConfigurationElement e) {
		SingleFilterHelper helper = null;
		try {
			ComrelFactory factory = ComrelFactory.eINSTANCE;
			ISingleFilterHelper i = (ISingleFilterHelper) e
					.createExecutableExtension("class");

			// Helper und Port erstellen
			MultiInputPort inPort = factory.createMultiInputPort();
			SingleOutputPort outPort = factory.createSingleOutputPort();
			helper = factory.createSingleFilterHelper();

			// Helper und Ports configurieren
			helper = configureHelperUnit(helper, e);
			inPort = configurePort(inPort, i.getInputPort());
			outPort = configurePort(outPort, i.getOutputPort());
			helper.setInputPort(inPort);
			helper.setOutputPort(outPort);

			return helper;
		} catch (Exception ex) {
			ex.printStackTrace();

		}
		return null;
	}

	/**
	 * Erstellt einen Helper
	 * 
	 * @param e
	 *            IConfigurableElement
	 * @return Helper
	 */
	private static MultiFilterHelper createMultiFilterHelper(
			IConfigurationElement e) {
		MultiFilterHelper helper = null;
		try {
			ComrelFactory factory = ComrelFactory.eINSTANCE;
			IMultiFilterHelper i = (IMultiFilterHelper) e
					.createExecutableExtension("class");

			// Helper und Port erstellen
			MultiInputPort inPort = factory.createMultiInputPort();
			MultiOutputPort outPort = factory.createMultiOutputPort();
			helper = factory.createMultiFilterHelper();

			// Helper und Ports configurieren
			helper = configureHelperUnit(helper, e);
			inPort = configurePort(inPort, i.getInputPort());
			outPort = configurePort(outPort, i.getOutputPort());
			helper.setInputPort(inPort);
			helper.setOutputPort(outPort);

			return helper;
		} catch (Exception ex) {
			ex.printStackTrace();

		}
		return null;
	}

	/**
	 * Erstellt einen Helper
	 * 
	 * @param e
	 *            IConfigurableElement
	 * @return Helper
	 */
	private static SingleFeatureHelper createSingleFeatureHelper(
			IConfigurationElement e) {
		SingleFeatureHelper helper = null;
		try {
			ComrelFactory factory = ComrelFactory.eINSTANCE;
			ISingleFeatureHelper i = (ISingleFeatureHelper) e
					.createExecutableExtension("class");

			// Helper und Port erstellen
			SingleInputPort inPort = factory.createSingleInputPort();
			SingleOutputPort outPort = factory.createSingleOutputPort();
			helper = factory.createSingleFeatureHelper();

			// Helper und Ports configurieren
			helper = configureHelperUnit(helper, e);
			inPort = configurePort(inPort, i.getInputPort());
			outPort = configurePort(outPort, i.getOutputPort());
			helper.setInputPort(inPort);
			helper.setOutputPort(outPort);

			return helper;
		} catch (Exception ex) {
			ex.printStackTrace();

		}
		return null;
	}

	/**
	 * Erstellt einen Helper
	 * 
	 * @param e
	 *            IConfigurableElement
	 * @return Helper
	 */
	private static MultiFeatureHelper createMultiFeatureHelper(
			IConfigurationElement e) {
		MultiFeatureHelper helper = null;
		try {
			ComrelFactory factory = ComrelFactory.eINSTANCE;
			IMultiFeatureHelper i = (IMultiFeatureHelper) e
					.createExecutableExtension("class");

			// Helper und Port erstellen
			SingleInputPort inPort = factory.createSingleInputPort();
			MultiOutputPort outPort = factory.createMultiOutputPort();
			helper = factory.createMultiFeatureHelper();

			// Helper und Ports configurieren
			helper = configureHelperUnit(helper, e);
			inPort = configurePort(inPort, i.getInputPort());
			outPort = configurePort(outPort, i.getOutputPort());
			helper.setInputPort(inPort);
			helper.setOutputPort(outPort);

			return helper;
		} catch (Exception ex) {
			ex.printStackTrace();

		}
		return null;
	}

	/**
	 * Konfiguriert einen Helper
	 * 
	 * @param <H>
	 * @param helper
	 * @param e
	 * @return
	 */
	private static <H extends Helper> H configureHelperUnit(H helper,
			IConfigurationElement e) {
		String id = e.getAttribute("id");
		String name = e.getAttribute("name");
		String namespaceUri = e.getAttribute("namespaceUri");
		helper.setHelperId(id);
		helper.setName(name);
		helper.setNamespaceUri(namespaceUri);
		return helper;
	}

	/**
	 * Konfiguriert einen Port
	 * 
	 * @param <P>
	 * @param configurablePort
	 *            der zu konfigurierende Port
	 * @param originalPort
	 *            der originalPort
	 * @return configurierter Port
	 */
	@SuppressWarnings("rawtypes")
	private static <P extends Port> P configurePort(P configurablePort,
			Port originalPort) {
		String name = originalPort.getName();
		Class type = originalPort.getType();
		String description = originalPort.getDescription();
		configurablePort.setName(name);
		configurablePort.setType(type);
		configurablePort.setDescription(description);
		return configurablePort;
	}

	/**
	 * Liefert alle EmfRefactorings
	 * @return
	 */
	public static Collection<ModelRefactoring> getEmfRefactoringsAsModelRefactorings() {
		return getEmfRefactoringsAsModelRefactorings("");
	}

	/**
	 * Liefert alle ModelRefactorings useses EmfRefactor-ExtensionPoint
	 */
	@SuppressWarnings("rawtypes")
	public static Collection<ModelRefactoring> getEmfRefactoringsAsModelRefactorings(
			String namespaceURI) {
		ComrelFactory comrelFactory = ComrelFactory.eINSTANCE;
//			(ComrelFactory) EPackage.Registry.INSTANCE
//				.getEFactory("comrel");
		List<Refactoring> refactorings = RefactoringManager.getAllRefactorings();
		Map<String, ModelRefactoring> atomics = new HashMap<String, ModelRefactoring>();
		ModelRefactoring atomic;
		Set<org.eclipse.emf.refactor.refactoring.core.Port> ports;
		SingleInputPort inputPort;
		if (namespaceURI == null) {
			namespaceURI = "";
		}
		for (Refactoring ref : refactorings) {
			// getInitialConditions(ref);
			if (namespaceURI.equals("")
					|| namespaceURI.equals(ref.getNamespaceUri())) {
				atomic = comrelFactory.createModelRefactoring(ref.getId());
				atomic.setName(ref.getName());
				atomic.setLabel(ref.getName());
				atomic.setNamespaceUri(ref.getNamespaceUri());
				ports = ref.getController().getDataManagementObject()
						.getInPorts();
				for (org.eclipse.emf.refactor.refactoring.core.Port p : ports) {
					inputPort = comrelFactory.createSingleInputPort();
					inputPort.setName(p.getName());
					inputPort.setType(p.getType());
					inputPort.setDescription(p.getDescription());

					atomic.getInputPorts().add(inputPort);
				}

				atomics.put(ref.getId(), atomic);
			}
		}
		return atomics.values();
	}

	/**
	 * Liefert alle NamespaceUris, gesammelt aus den emfRefactorings
	 * 
	 * @return namspaceUris
	 */
	public static Set<String> getNamepsaceURIS() {
		TreeSet<String> result = new TreeSet<String>();
		for (ModelRefactoring ref : RegistryUtil.getEmfRefactoringsAsModelRefactorings()) {
			result.add(ref.getNamespaceUri());
		}
		return result;
	}

}