plugins/org.eclipse.jst.j2ee/archiveops/org/eclipse/jst/j2ee/internal/archive/JavaEEEMFArchiveAdapterHelper.java

/*******************************************************************************
 * Copyright (c) 2005, 2007 IBM Corporation and others.
 * 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:
 *     IBM Corporation - initial API and implementation
 *******************************************************************************/
package org.eclipse.jst.j2ee.internal.archive;

import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.InputStream;
import java.lang.reflect.Constructor;
import java.lang.reflect.InvocationTargetException;
import java.util.HashMap;
import java.util.Map;

import org.eclipse.core.runtime.IPath;
import org.eclipse.core.runtime.Platform;
import org.eclipse.core.runtime.content.IContentDescription;
import org.eclipse.emf.common.notify.Adapter;
import org.eclipse.emf.common.notify.impl.AdapterImpl;
import org.eclipse.emf.common.util.EList;
import org.eclipse.emf.common.util.URI;
import org.eclipse.emf.ecore.EObject;
import org.eclipse.emf.ecore.resource.ContentHandler;
import org.eclipse.emf.ecore.resource.Resource;
import org.eclipse.emf.ecore.resource.ResourceSet;
import org.eclipse.emf.ecore.resource.impl.ResourceSetImpl;
import org.eclipse.jst.jee.archive.ArchiveModelLoadException;
import org.eclipse.jst.jee.archive.IArchive;
import org.eclipse.jst.jee.archive.IArchiveResource;
import org.eclipse.jst.jee.archive.internal.ArchiveURIConverter;
import org.eclipse.jst.jee.archive.internal.ArchiveUtil;
import org.eclipse.wst.common.componentcore.internal.impl.WTPResourceFactoryRegistry;
import org.eclipse.wst.common.internal.emf.resource.EMF2SAXRendererFactory;
import org.eclipse.wst.common.internal.emf.resource.IRootObjectResource;
import org.eclipse.wst.common.internal.emf.resource.RendererFactory;
import org.eclipse.wst.common.internal.emf.resource.TranslatorResourceFactory;

public class JavaEEEMFArchiveAdapterHelper {

	public static IArchive findArchive(EObject eObject){
		EList <Adapter> adapters = eObject.eResource().getResourceSet().eAdapters();
		for(Adapter adapter:adapters){
			if(adapter instanceof EMFAddapter){
				return ((EMFAddapter) adapter).getHelper().getArchive();
			}
		}
		return null;
	}
	
	private class EMFAddapter extends AdapterImpl {
		private JavaEEEMFArchiveAdapterHelper helper;
		public EMFAddapter(JavaEEEMFArchiveAdapterHelper helper){
			this.helper = helper;
		}
		public JavaEEEMFArchiveAdapterHelper getHelper() {
			return this.helper;
		}
	}

	protected ResourceSet resourceSet;

	private EMFAddapter adapter = null;

	private IArchive archive = null;

	public JavaEEEMFArchiveAdapterHelper() {
	}

	public JavaEEEMFArchiveAdapterHelper(IArchive anArchive) {
		setArchive(anArchive);
	}

	public void setArchive(IArchive anArchive) {
		this.archive = anArchive;
	}

	public IArchive getArchive() {
		return archive;
	}

	public boolean containsModelObject(IPath modelObjectPath) {
		IArchive archive = getArchive();
		if (archive.containsArchiveResource(modelObjectPath)) {
			URI uri = getArchiveURIConverter().getURI(modelObjectPath);
			return containsResource(uri);
		}
		return false;
	}

	protected boolean containsResource(URI uri) {
		// TODO figure out a way to figure this out without actually
		// loading the resource
		IRootObjectResource resource = (IRootObjectResource) getResourceSet().getResource(uri, true);
		if (resource != null && resource.getRootObject() != null) {
			return true;
		}
		return false;
	}

	protected ArchiveURIConverter archiveURIConverter;

	public void setArchiveURIConverter(ArchiveURIConverter archiveURIConverter) {
		this.archiveURIConverter = archiveURIConverter;
	}

	public ArchiveURIConverter getArchiveURIConverter() {
		if (archiveURIConverter == null) {
			archiveURIConverter = new ArchiveURIConverter(getArchive());
		}
		return archiveURIConverter;
	}

	public Resource getResource(IPath resourcePath) throws ArchiveModelLoadException {
		URI uri = getArchiveURIConverter().getURI(resourcePath);
		Resource resource = getResourceSet().getResource(uri, true);
		return resource;
	}
	
	public Object getModelObject(IPath modelObjectPath) throws ArchiveModelLoadException {
		IRootObjectResource resource = (IRootObjectResource) getResource(modelObjectPath);
		return resource.getRootObject();
	}

	public ResourceSet getResourceSet() {
		if (resourceSet == null) {
			initializeResourceSet();
			if (null == adapter) {
				adapter = new EMFAddapter(this);
			}
			resourceSet.eAdapters().add(adapter);
		}
		return resourceSet;
	}

	public void setResourceSet(org.eclipse.emf.ecore.resource.ResourceSet newResourceSet) {
		if (resourceSet != newResourceSet) {
			// remove adapter from old resource set
			if (resourceSet != null && adapter != null) {
				resourceSet.eAdapters().remove(adapter);
			}
			// add as adapter to new resource set if necessary
			if (newResourceSet != null && !newResourceSet.eAdapters().contains(adapter)) {
				if (adapter == null) {
					adapter = new EMFAddapter(this);
				}
				newResourceSet.eAdapters().add(adapter);
			}
			resourceSet = newResourceSet;
		} // no need to update if old set equals new set (by reference)
	}

	public void initializeResourceSet() {
		ResourceSet rs = new ResourceSetImpl() {
			final String JAVA_PROTOCOL_URI_SCHEME = "java"; //$NON-NLS-1$
			private IContentDescription getContentDescription(URI uri) {
				IArchiveResource archiveResource = null;
				InputStream ioStream = null;
				try {
					IPath path = getArchiveURIConverter().getPath(uri);
					archiveResource = getArchive().getArchiveResource(path);
					ioStream = archiveResource.getInputStream();
					IContentDescription description = Platform.getContentTypeManager().getDescriptionFor(ioStream, path.lastSegment(), IContentDescription.ALL);
					return description;
				} catch (FileNotFoundException e) {
					ArchiveUtil.warn(e);
					return null;
				} catch (IOException e) {
					ArchiveUtil.warn(e);
					return null;
				} finally {
					if (ioStream != null) {
						try {
							ioStream.close();
						} catch (IOException e) {
							ArchiveUtil.warn(e);
						}
					}
				}
			}

			@Override
			public Resource createResource(URI uri) {
				return createResource(uri, ContentHandler.UNSPECIFIED_CONTENT_TYPE);
			}
			
			@Override
			public Resource createResource(URI uri, String contentType) {
				IContentDescription description = null;
				if (!isJavaURI(uri))
					description = getContentDescription(uri);

				Resource.Factory resourceFactory = null;
				if (null != description) {
					SAXFactoryKey key = new SAXFactoryKey(uri, description);
					resourceFactory = getSAXResourceFactory(key);
					if (null == resourceFactory) {
						resourceFactory = ((WTPResourceFactoryRegistry) getResourceFactoryRegistry()).getFactory(uri, description);
						Class clazz = resourceFactory.getClass();
						boolean isTranslator = false;
						while (!isTranslator && clazz != null) {
							if (clazz == TranslatorResourceFactory.class) {
								isTranslator = true;
							} else {
								clazz = clazz.getSuperclass();
							}
						}
						if (isTranslator) {
							try {
								Constructor constructor = resourceFactory.getClass().getConstructor(RendererFactory.class);
								EMF2SAXRendererFactory.INSTANCE.setValidating(false);
								resourceFactory = (Resource.Factory) constructor.newInstance(EMF2SAXRendererFactory.INSTANCE);
							} catch (SecurityException e) {
								ArchiveUtil.warn(e);
							} catch (NoSuchMethodException e) {
								ArchiveUtil.warn(e);
							} catch (IllegalArgumentException e) {
								ArchiveUtil.warn(e);
							} catch (InstantiationException e) {
								ArchiveUtil.warn(e);
							} catch (IllegalAccessException e) {
								ArchiveUtil.warn(e);
							} catch (InvocationTargetException e) {
								ArchiveUtil.warn(e);
							}
						}
						setSAXResourceFactory(key, resourceFactory);
					}
				} else {
					resourceFactory = getResourceFactoryRegistry().getFactory(uri);
				}

				if (resourceFactory != null) {
					Resource result = resourceFactory.createResource(uri);
					getResources().add(result);
					return result;
				}
				return null;
			}

			private boolean isJavaURI(URI uri) {
				return JAVA_PROTOCOL_URI_SCHEME.equals(uri.scheme());
			}
		};
		rs.setResourceFactoryRegistry(WTPResourceFactoryRegistry.INSTANCE);
		rs.setURIConverter(getArchiveURIConverter());
		setResourceSet(rs);
	}

	private class SAXFactoryKey {
		private URI uri = null;

		private IContentDescription description = null;

		public SAXFactoryKey(URI uri, IContentDescription description) {
			this.uri = uri;
			this.description = description;
			if(uri == null){
				throw new NullPointerException();
			}
			if(description == null){
				throw new NullPointerException();
			}
		}
		
		@Override
		public boolean equals(Object obj){
			if(obj == null || !(obj instanceof SAXFactoryKey)){
				return false;
			}
			SAXFactoryKey other = (SAXFactoryKey)obj;
			return uri.equals(other.uri) && description.equals(other.description);
		}

		@Override
		public int hashCode() {
			return uri.hashCode() + description.hashCode();
		}
	}

	private static Map<SAXFactoryKey, Resource.Factory> localFactoryMap = new HashMap<SAXFactoryKey, Resource.Factory>();

	private static Resource.Factory getSAXResourceFactory(SAXFactoryKey key) {
		synchronized (localFactoryMap) {
			return localFactoryMap.get(key);
		}
	}

	private static void setSAXResourceFactory(SAXFactoryKey key, Resource.Factory resourceFactory) {
		synchronized (localFactoryMap) {
			localFactoryMap.put(key, resourceFactory);
		}
	}
}