plugins/org.eclipse.jem.proxy/proxyide/org/eclipse/jem/internal/proxy/ide/IDEProxyFactoryRegistry.java

/*******************************************************************************
 * Copyright (c) 2001, 2005 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.jem.internal.proxy.ide;
/*


 */

import java.net.URL;
import java.net.URLClassLoader;
import java.util.*;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.core.runtime.Platform;
import org.osgi.framework.Bundle;

import org.eclipse.jem.internal.proxy.common.IVMServer;
import org.eclipse.jem.internal.proxy.core.*;
/**
 * This implementation runs the Beans inside the Eclipse IDE
 * It should only be used by plugins that can guarantee their their beans do
 * not change during the lifetime of the IDE and can run at the same JDK level
 * that the Eclipse IDE is running
 */

public class IDEProxyFactoryRegistry extends BaseProxyFactoryRegistry implements IVMServer {

	public static final String IDE_REGISTRY_TYPE_ID = "org.eclipse.jem.IDE";	//$NON-NLS-1$
	protected String fName;
	protected ClassLoader fClassLoader;
	protected IDECallbackRegistry fCallbackRegistry;
	
	/*
	 * Special classloader that firsts tries to load from bundle then tries from url paths so
	 * that bundle is treated as being at the head of the url paths.
	 * 
	 * @since 1.0.0
	 */
	private static class IDESpecialClassLoader extends URLClassLoader {
		
		private Bundle bundle;
		// This is the bundle that contains the IDE Eclipse code.
		// This must be checked first because there are IDE specific stuff that is used on the "remote vm" too and
		// so must be common.
		private Bundle ideBundle;	 

		public IDESpecialClassLoader(URL[] urls, Bundle bundle) {
			super(urls, null);
			ideBundle = ProxyPlugin.getPlugin().getBundle();
			this.bundle = bundle;
		}
		
		public IDESpecialClassLoader(URL[] urls) {
			this(urls, null);
		}
		
		/* (non-Javadoc)
		 * @see java.lang.ClassLoader#findClass(java.lang.String)
		 */
		protected Class findClass(String name) throws ClassNotFoundException {
			try {
				return ideBundle.loadClass(name);
			} catch (ClassNotFoundException e) {
				if (bundle != null) {
					try {
						return bundle.loadClass(name);
					} catch (ClassNotFoundException e1) {
					}
				}
				return super.findClass(name);
			}
		}
		
		/*
		 * (non-Javadoc)
		 * 
		 * @see java.lang.ClassLoader#findResource(java.lang.String)
		 */
		public URL findResource(String name) {
			URL r = ideBundle.getResource(name);
			if (r == null && bundle != null)
				r = bundle.getResource(name);
			return r != null ? r : super.findResource(name);
		}
}

/**
 * Create a special loader that has the plugin classloader of the passed in plugin
 * as the parent loader, plus all of the urls, plus the remotevm.jar file that is
 * needed by IDE Proxy to work.
 */	
public static ClassLoader createSpecialLoader(String pluginName, URL[] otherURLs) {
	Bundle bundle = pluginName != null ? Platform.getBundle(pluginName) : null;
	
	URL[] mustHaveUrls = ProxyPlugin.getPlugin().urlLocalizeAllFromBundleAndFragments(ProxyPlugin.getPlugin().getBundle(), "vm/remotevm.jar"); //$NON-NLS-1$
	
	URL[] urls = null;
	if (otherURLs != null) {
		urls = new URL[otherURLs.length+mustHaveUrls.length];
		System.arraycopy(mustHaveUrls, 0, urls, 0, mustHaveUrls.length);
		System.arraycopy(otherURLs, 0, urls, mustHaveUrls.length, otherURLs.length);
	} else 
		urls = mustHaveUrls;
		
	return bundle != null ? new IDESpecialClassLoader(urls, bundle) : new IDESpecialClassLoader(urls);
}

public IDEProxyFactoryRegistry(String aName, ClassLoader loader) {
	super(IDE_REGISTRY_TYPE_ID);
	fName = aName;
	fClassLoader = loader;
}

ClassLoader getPluginClassLoader(){
	return fClassLoader;
}

protected void registryTerminated(boolean wait){
	List runnables = null;
	synchronized (this) {
		runnables = shutdownRunnables;
		shutdownRunnables = null;
	}
	if (runnables != null) {
		for (Iterator itr = runnables.iterator(); itr.hasNext();) {
			try {
				((Runnable) itr.next()).run();
			} catch (RuntimeException e) {
				e.printStackTrace();
			}
		}
	}
}

Class loadClass(String aClassName) throws ClassNotFoundException, ExceptionInInitializerError, LinkageError {
	return fClassLoader.loadClass(aClassName);
}

public ICallbackRegistry getCallbackRegistry(){
	if ( fCallbackRegistry == null ){
		fCallbackRegistry = new IDECallbackRegistry(this);
	}
	return fCallbackRegistry;
}


/**
 * Get a bean proxy from the bean of the correct type.
 * 
 * @param returnType
 * @param bean
 * @return
 * 
 * @since 1.0.0
 */
IBeanProxy getBeanProxy(Class returnType, Object bean) {
	IDEStandardBeanTypeProxyFactory proxyFactory = (IDEStandardBeanTypeProxyFactory) this.getBeanTypeProxyFactory();
	if (!returnType.isPrimitive()) {
		return IDEStandardBeanProxyFactory.createBeanProxy(this, bean);
	} else if (returnType == Integer.TYPE) {
		return proxyFactory.intType.newBeanProxy(bean);
	} else if (returnType == Boolean.TYPE) {
		return proxyFactory.booleanType.newBeanProxy(bean);
	} else if (returnType == Float.TYPE) {
		return proxyFactory.floatType.newBeanProxy(bean);
	} else if (returnType == Long.TYPE) {
		return proxyFactory.longType.newBeanProxy(bean);
	} else if (returnType == Short.TYPE) {
		return proxyFactory.shortType.newBeanProxy(bean);
	} else if (returnType == Double.TYPE) {
		return proxyFactory.doubleType.newBeanProxy(bean);
	} else if (returnType == Byte.TYPE) {
		return proxyFactory.byteType.newBeanProxy(bean);
	} else if (returnType == Character.TYPE) {
		return proxyFactory.charType.newBeanProxy(bean);
	} else {
		throw new RuntimeException("Unknown primitive type " + returnType.getName()); //$NON-NLS-1$
	}
}

List shutdownRunnables;

public synchronized void addShutdownListener(Runnable runnable) {
	if (shutdownRunnables == null) {
		shutdownRunnables = new ArrayList();
	} else if (shutdownRunnables.contains(runnable))
		return;
	shutdownRunnables.add(runnable);
}

public synchronized void removeShutdownListener(Runnable runnable) {
	if (shutdownRunnables != null)
		shutdownRunnables.remove(runnable);
}

}