org.eclipse.emf.emfstore.client/src/org/eclipse/emf/emfstore/client/model/util/ModelElementWrapperDescriptor.java

/*******************************************************************************
 * Copyright (c) 2008-2011 Chair for Applied Software Engineering,
 * Technische Universitaet Muenchen.
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 * 
 * Contributors:
 ******************************************************************************/
package org.eclipse.emf.emfstore.client.model.util;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import org.eclipse.core.runtime.CoreException;
import org.eclipse.core.runtime.IConfigurationElement;
import org.eclipse.core.runtime.IExtension;
import org.eclipse.core.runtime.Platform;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;

/**
 * Uses all registered extensions to create a wrapper for the given element. <br>
 * The factories are processed in the following order:<br>
 * <li>Factories by nsURI</li><br>
 * <li>Default factories</li>
 */
public class ModelElementWrapperDescriptor {

	private static final String EP_ID = "org.eclipse.emf.emfstore.client.wrapperfactories";
	private static final String NON_URI = "NON_URI";
	private static final String ATT_CLASS = "class";
	private static final String ATT_URI = "nsURI";

	private static final ModelElementWrapperDescriptor INSTANCE = new ModelElementWrapperDescriptor();
	private static Map<String, List<IModelElementWrapperFactory>> factoriesMap;

	/**
	 * Returns the instance of this class.
	 * 
	 * @return the instance
	 */
	public static ModelElementWrapperDescriptor getInstance() {
		return INSTANCE;
	}

	/**
	 * Returns all currently registered provider. The implementation does not track extensions which are added after
	 * this snapshot.
	 * 
	 * @return the map from uri to factory
	 */
	public static synchronized Map<String, List<IModelElementWrapperFactory>> getFactories() {
		if (factoriesMap != null) {
			return factoriesMap;
		}

		factoriesMap = new HashMap<String, List<IModelElementWrapperFactory>>();
		IExtension[] extensions = Platform.getExtensionRegistry().getExtensionPoint(EP_ID).getExtensions();
		for (int i = 0; i < extensions.length; i++) {
			IConfigurationElement[] configElements = extensions[i].getConfigurationElements();
			for (int j = 0; j < configElements.length; j++) {
				IConfigurationElement configurationElement = configElements[j];
				try {
					IModelElementWrapperFactory factory = (IModelElementWrapperFactory) configurationElement
						.createExecutableExtension(ATT_CLASS);
					String nsURI = getNsURI(configurationElement);
					if (!factoriesMap.containsKey(nsURI)) {
						factoriesMap.put(nsURI, new ArrayList<IModelElementWrapperFactory>());
					}
					List<IModelElementWrapperFactory> list = factoriesMap.get(nsURI);
					list.add(factory);
				} catch (CoreException e) {
					WorkspaceUtil.logException("Creating the wrapperfactories ", e);
				}
			}
		}
		return factoriesMap;
	}

	/**
	 * Returns the nsURI from the {@link IConfigurationElement}.
	 * 
	 * @param configurationElement
	 * @return
	 */
	private static String getNsURI(IConfigurationElement configurationElement) {
		String nsURI = configurationElement.getAttribute(ATT_URI);
		return nsURI != null ? nsURI : NON_URI;
	}

	/**
	 * Wraps the given {@link EObject}.
	 * 
	 * @param container the container for which the toWrap should be wrapped or <code>null</code>.
	 * @param toWrap the {@link EObject} which should be wrapped.
	 * @return the wrapped element
	 */
	public EObject wrap(EObject container, EObject toWrap) {
		ensureFactories();
		return wrap(container, toWrap, new DefaultWrapHelper());
	}

	/**
	 * Wraps the given {@link EObject} for import purpose.
	 * 
	 * @param container the container for which the toWrap should be wrapped or <code>null</code>.
	 * @param toWrap the {@link EObject} which should be wrapped.
	 * @param resourceUri the {@link URI} of the resource to import.
	 * @param resourceIndex - the index of the element inside the eResource.
	 * @return the wrapped element
	 */
	public EObject wrapForImport(EObject container, EObject toWrap, URI resourceUri, int resourceIndex) {
		ensureFactories();
		return wrap(container, toWrap, new ImportWrapHelper(resourceUri, resourceIndex));
	}

	/**
	 * Loads the factories if not loaded yet.
	 */
	private void ensureFactories() {
		getFactories();
	}

	/**
	 * Wraps the toWrap using the wrapHelper.
	 * 
	 * @param container container the container for which the toWrap should be wrapped or <code>null</code>.
	 * @param toWrap the {@link EObject} which should be wrapped.
	 * @param helper a wrap helper
	 * @return
	 */
	private EObject wrap(EObject container, EObject toWrap, WrapHelper helper) {
		EObject wrapped;
		if (toWrap == null) {
			return null;
		}
		// use the nsURI of the toWrap to find a factory
		String nsURI = toWrap.eClass().getEPackage().getNsURI();
		if (factoriesMap.containsKey(nsURI)) {
			List<IModelElementWrapperFactory> factories = factoriesMap.get(nsURI);
			// iterate all the factories registered for the nsURI. The first matching wins.
			for (IModelElementWrapperFactory factory : factories) {
				if (factory.isFor(container, toWrap)) {
					wrapped = helper.wrap(factory, container, toWrap);
					if (wrapped != null) {
						return wrapped;
					}
				}
			}
		}

		// if the element could not be wrapped by its nsURI, try the default factories
		return wrapWithoutNsURI(container, toWrap, helper);
	}

	/**
	 * Uses the factories which did not specify a nsURI to create the wrapper.
	 * 
	 * @param container
	 * @param toWrap
	 * @param helper a wrap helper
	 * @return
	 */
	private EObject wrapWithoutNsURI(EObject container, EObject toWrap, WrapHelper helper) {
		EObject wrapped = null;
		if (factoriesMap.containsKey(NON_URI)) {
			List<IModelElementWrapperFactory> factories = factoriesMap.get(NON_URI);
			// iterate all the factories registered for the nsURI. The first matching wins.
			for (IModelElementWrapperFactory factory : factories) {
				if (factory.isFor(container, toWrap)) {
					wrapped = helper.wrap(factory, container, toWrap);
					if (wrapped != null) {
						break;
					}
				}
			}
		}
		return wrapped;
	}

	/**
	 * An abstraction for the different wrapping types.
	 */
	private interface WrapHelper {
		EObject wrap(IModelElementWrapperFactory factory, EObject container, EObject toWrap);
	}

	/**
	 * Is used to wrap imported elements.
	 */
	private final class ImportWrapHelper implements WrapHelper {

		private final URI uri;
		private final int resourceIndex;

		private ImportWrapHelper(URI uri, int resourceIndex) {
			this.uri = uri;
			this.resourceIndex = resourceIndex;
		}

		public EObject wrap(IModelElementWrapperFactory factory, EObject container, EObject toWrap) {
			return factory.wrapForImport(toWrap, uri, resourceIndex);
		}

	}

	/**
	 * To wrap default elements.
	 */
	private class DefaultWrapHelper implements WrapHelper {

		public EObject wrap(IModelElementWrapperFactory factory, EObject container, EObject toWrap) {
			return factory.wrap(toWrap);
		}

	}
}