/*******************************************************************************
 * 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.remote;

/*


 */

import java.text.MessageFormat;
import java.util.*;

import org.eclipse.core.runtime.IStatus;
import org.eclipse.core.runtime.Status;
import org.eclipse.jem.internal.proxy.core.*;
import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
import org.eclipse.jem.internal.proxy.common.CommandException;
import org.eclipse.jem.internal.proxy.common.MapTypes;
import org.eclipse.jem.internal.proxy.common.remote.CommandErrorException;
import org.eclipse.jem.internal.proxy.common.remote.Commands;

/**
 * We are a beanTypeProxyFactory for creating REMBeanTypeProxy objects Primitive types as well as common types like String are cached for speed of
 * lookup. We are the standard one that the VCE uses. Creation date: (12/3/99 2:32:48 PM)
 * 
 * @author: Joe Winchester
 */
public final class REMStandardBeanTypeProxyFactory implements IStandardBeanTypeProxyFactory {

	protected final REMProxyFactoryRegistry fFactoryRegistry;

	protected REMStandardBeanProxyFactory fBeanFactory;

	// Hashtable to cache proxies for classes so they are found on second and subsequent lookups
	protected Map fBeanProxies = new HashMap(1000);

	// A Cache of bean type proxies that should not ever be released. These are the standard ones
	// that we create here. They are never released because they wouldn't be correctly re-created
	// if they were. Also they are standard ones with standard ID's that don't change so they
	// don't need to be re-created later.
	protected Set fPermanentProxies = new HashSet(30);

	// Cache of requested but not found bean types. If not maintaining the list, this variable will be null.
	// The values are strings (classnames in JNI format).
	protected Set fNotFoundTypes = null;

	// Cached copy of a few typical bean type proxies.
	REMBeanTypeProxy objectClass;

	REMClassBeanTypeProxy classClass;

	REMVoidBeanTypeProxy voidType;

	REMBooleanTypeBeanTypeProxy booleanType;

	REMBooleanClassBeanTypeProxy booleanClass;

	REMIntegerTypeBeanTypeProxy intType;

	REMIntegerClassBeanTypeProxy integerClass;

	REMByteTypeBeanTypeProxy byteType;

	REMByteClassBeanTypeProxy byteClass;

	REMShortClassBeanTypeProxy shortClass;

	REMShortTypeBeanTypeProxy shortType;

	REMLongClassBeanTypeProxy longClass;

	REMLongTypeBeanTypeProxy longType;

	REMDoubleClassBeanTypeProxy doubleClass;

	REMDoubleTypeBeanTypeProxy doubleType;

	REMFloatClassBeanTypeProxy floatClass;

	REMFloatTypeBeanTypeProxy floatType;

	REMBigDecimalBeanTypeProxy bigDecimalClass;

	REMBigIntegerBeanTypeProxy bigIntegerClass;

	REMCharacterTypeBeanTypeProxy charType;

	REMCharacterClassBeanTypeProxy characterClass;

	REMStringBeanTypeProxy stringClass;

	/**
	 * Available to all REM beantypes.
	 */
	public REMProxyConstants proxyConstants;

	/**
	 * IDEBeanTypeProxyFactory constructor comment.
	 */
	REMStandardBeanTypeProxyFactory(REMProxyFactoryRegistry aRegistry) {
		fFactoryRegistry = aRegistry;
		aRegistry.registerBeanTypeProxyFactory(this);

		proxyConstants = new REMProxyConstants(aRegistry);

		// Now initialize the cache.
		objectClass = new REMBeanTypeProxy(fFactoryRegistry, new Integer(Commands.OBJECT_CLASS), Object.class.getName(), null);
		classClass = new REMClassBeanTypeProxy(fFactoryRegistry, objectClass);
		voidType = new REMVoidBeanTypeProxy(fFactoryRegistry);
		booleanType = new REMBooleanTypeBeanTypeProxy(fFactoryRegistry);
		booleanClass = new REMBooleanClassBeanTypeProxy(fFactoryRegistry, objectClass);
		IBeanTypeProxy numberClass = objectClass.newBeanTypeForClass(new Integer(Commands.NUMBER_CLASS), Number.class.getName(), true);
		intType = new REMIntegerTypeBeanTypeProxy(fFactoryRegistry);
		integerClass = new REMIntegerClassBeanTypeProxy(fFactoryRegistry, numberClass);
		byteType = new REMByteTypeBeanTypeProxy(fFactoryRegistry);
		byteClass = new REMByteClassBeanTypeProxy(fFactoryRegistry, numberClass);
		shortType = new REMShortTypeBeanTypeProxy(fFactoryRegistry);
		shortClass = new REMShortClassBeanTypeProxy(fFactoryRegistry, numberClass);
		longType = new REMLongTypeBeanTypeProxy(fFactoryRegistry);
		longClass = new REMLongClassBeanTypeProxy(fFactoryRegistry, numberClass);
		doubleType = new REMDoubleTypeBeanTypeProxy(fFactoryRegistry);
		doubleClass = new REMDoubleClassBeanTypeProxy(fFactoryRegistry, numberClass);
		floatType = new REMFloatTypeBeanTypeProxy(fFactoryRegistry);
		floatClass = new REMFloatClassBeanTypeProxy(fFactoryRegistry, numberClass);
		bigDecimalClass = new REMBigDecimalBeanTypeProxy(fFactoryRegistry, numberClass);
		bigIntegerClass = new REMBigIntegerBeanTypeProxy(fFactoryRegistry, numberClass);
		charType = new REMCharacterTypeBeanTypeProxy(fFactoryRegistry);
		characterClass = new REMCharacterClassBeanTypeProxy(fFactoryRegistry, objectClass);
		stringClass = new REMStringBeanTypeProxy(fFactoryRegistry, objectClass);
		IBeanTypeProxy throwableClass = new REMThrowableBeanTypeProxy(fFactoryRegistry, new Integer(Commands.THROWABLE_CLASS), Throwable.class
				.getName(), objectClass);
		IBeanTypeProxy threadClass = objectClass.newBeanTypeForClass(new Integer(Commands.THREAD_CLASS), Thread.class.getName(), false);
		IBeanTypeProxy expressionProcessorControllerClass = objectClass.newBeanTypeForClass(new Integer(Commands.EXPRESSIONPROCESSERCONTROLLER_CLASS), "org.eclipse.jem.internal.proxy.vm.remote.ExpressionProcesserController", false); //$NON-NLS-1$

		// Initialize the hashtable with the primitives, their lang equivalents, and also common classes like String

		// Primitives
		fBeanProxies.put(voidType.getTypeName(), voidType);
		fBeanProxies.put(intType.getTypeName(), intType);
		fBeanProxies.put(booleanType.getTypeName(), booleanType);
		fBeanProxies.put(charType.getTypeName(), charType);
		fBeanProxies.put(byteType.getTypeName(), byteType);
		fBeanProxies.put(shortType.getTypeName(), shortType);
		fBeanProxies.put(longType.getTypeName(), longType);
		fBeanProxies.put(floatType.getTypeName(), floatType);
		fBeanProxies.put(doubleType.getTypeName(), doubleType);

		// java.lang primitive peers
		// Note that special classes are used for some of these which allow the IDE to get the
		// lang objects from the objects that are holding proxies
		fBeanProxies.put(integerClass.getTypeName(), integerClass);
		fBeanProxies.put(booleanClass.getTypeName(), booleanClass);
		fBeanProxies.put(characterClass.getTypeName(), characterClass);
		fBeanProxies.put(byteClass.getTypeName(), byteClass);
		fBeanProxies.put(shortClass.getTypeName(), shortClass);
		fBeanProxies.put(longClass.getTypeName(), longClass);
		fBeanProxies.put(floatClass.getTypeName(), floatClass);
		fBeanProxies.put(doubleClass.getTypeName(), doubleClass);
		fBeanProxies.put(bigDecimalClass.getTypeName(), bigDecimalClass);
		fBeanProxies.put(bigIntegerClass.getTypeName(), bigIntegerClass);
		fBeanProxies.put(stringClass.getTypeName(), stringClass);
		fBeanProxies.put(throwableClass.getTypeName(), throwableClass);
		fBeanProxies.put(objectClass.getTypeName(), objectClass);
		fBeanProxies.put(classClass.getTypeName(), classClass);
		fBeanProxies.put(numberClass.getTypeName(), numberClass);
		fBeanProxies.put(threadClass.getTypeName(), threadClass);
		fBeanProxies.put(expressionProcessorControllerClass.getTypeName(), expressionProcessorControllerClass);

		// Mark these as permanent.
		fPermanentProxies.addAll(fBeanProxies.values());
	}

	/**
	 * Initialize AFTER BeanProxyFactory has been created. This is REQUIRED! NOTE: It is package protected so that only REMStandardBeanProxyFactory
	 * can call it when ready.
	 */
	synchronized void initialize(REMStandardBeanProxyFactory proxyFactory) {
		fBeanFactory = proxyFactory;
		fBeanFactory.registerProxies(fBeanProxies.values());
	}

	/*
	 * This is called when we know we don't have the class registered, so we need to create the proxy. We have a connection passed in and will reuse
	 * it as necessary
	 * 
	 * It is important that this be called only from within a transaction.
	 */
	private synchronized IREMBeanTypeProxy createBeanTypeProxy(String typeName, IREMConnection connection) throws CommandException {

		// We don't have the beantype proxy, so create it.
		IREMBeanTypeProxy beanTypeProxy = null;
		Commands.GetClassReturn ret = null;
		try {
			ret = getClassReturn(connection, typeName);
		} catch (ThrowableProxy ep) {
			// Print out the trace and return proxy with init error.
			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", ep)); //$NON-NLS-1$
			IREMBeanTypeProxy proxy = new REMInitErrorBeanTypeProxy(fFactoryRegistry, MessageFormat.format(ProxyRemoteMessages.ExceptionErrorMsg_EXC_, new Object[] { ep.getTypeProxy().getTypeName(), ep.getProxyLocalizedMessage()}), typeName); //$NON-NLS-1$
			registerBeanTypeProxy(proxy, false);
			return proxy;
		}
		if (ret == null) {
			if (fNotFoundTypes != null)
				fNotFoundTypes.add(typeName);
			return null; // The class doesn't even exist on the server.
		}

		if (typeName.charAt(0) != '[') {
			// It is not an array.
			IREMBeanTypeProxy superTypeProxy = null;
			if (!ret.isInterface && ret.superClassname.length() != 0) {
				// Get the beantype proxy of the superclass.
				superTypeProxy = getBeanTypeProxy(ret.superClassname, connection);
			}

			// First check with the factory for the package of the class.
			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
			// the package ended and the class started. This check is here in case the
			// extension factory can handle this class but needs the id from the server to
			// create it.
			int packageIndex = typeName.lastIndexOf('.');
			if (packageIndex != -1) {
				String packageName = typeName.substring(0, packageIndex);
				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
				if (packageFactory != null) {
					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName, new Integer(ret.classID), superTypeProxy);
					if (beanTypeProxy != null) {
						registerBeanTypeProxy(beanTypeProxy, false);
						return beanTypeProxy;
					}
				}
			}

			if (ret.isInterface) {
				// Interface never have a super type, so we will create a specific type.
				beanTypeProxy = new REMInterfaceBeanTypeProxy(fFactoryRegistry, new Integer(ret.classID), typeName);
			} else {
				// Ask the supertype
				// to create a beantype proxy of the same beantype proxy class.
				// This is so that any subclasses will get the same beantype proxy class
				// for it if it is special.
				if (superTypeProxy != null)
					beanTypeProxy = superTypeProxy.newBeanTypeForClass(new Integer(ret.classID), typeName, ret.isAbstract);
			}
		} else
			beanTypeProxy = new REMArrayBeanTypeProxy(fFactoryRegistry, new Integer(ret.classID), typeName, objectClass);

		// Cache the instance so we can re-use it again
		if (beanTypeProxy != null)
			registerBeanTypeProxy(beanTypeProxy, false);
		return beanTypeProxy;
	}

	/**
	 * Using the helper class to find a class by name, then create the proxy.
	 */
	public IBeanTypeProxy getBeanTypeProxy(String typeName) {
		try {
			return getBeanTypeProxy(MapTypes.getJNIFormatName(typeName), (IREMConnection) null);
		} catch (CommandException e) {
			// Try once more (we won't have received recoverable exceptions here, they were already caught and handled)
			try {
				return getBeanTypeProxy(typeName, (IREMConnection) null);
			} catch (CommandException eAgain) {
				// Failed again.
				ProxyPlugin.getPlugin().getLogger().log(
						new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
			}
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IExpression,
	 *      java.lang.String)
	 */
	public synchronized IProxyBeanType getBeanTypeProxy(IExpression expression, String typeName) {
		typeName = MapTypes.getJNIFormatName(typeName);
		// See whether we already have the proxy for the argument name
		IProxyBeanType beanTypeProxy = (IProxyBeanType) fBeanProxies.get(typeName);
		if (beanTypeProxy != null)
			return beanTypeProxy;
		
		// Now see if an expression proxy cached.
		beanTypeProxy = ((REMExpression) expression).getBeanType(typeName);
		if (beanTypeProxy != null)
			return beanTypeProxy;		

		// If not an array, then see if the package extension mechanism can find it.
		// Do this here so that if it is found in the package extension we won't necessarily create an
		// extra connection when not needed.
		if (typeName.charAt(0) != '[') {
			// It is not an array
			// First check with the factory for the package of the class.
			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
			// the package ended and the class started.
			int packageIndex = typeName.lastIndexOf('.');
			if (packageIndex != -1) {
				String packageName = typeName.substring(0, packageIndex);
				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
				if (packageFactory != null) {
					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName, expression);
					if (beanTypeProxy != null) {
						registerBeanTypeProxy(beanTypeProxy, false);
						return beanTypeProxy;
					}
				}
			}
		}

		// Need to create the expression proxy for it.
		beanTypeProxy = ((Expression) expression).createBeanTypeExpressionProxy(typeName);
		registerBeanTypeProxy(beanTypeProxy, false);
		return beanTypeProxy;

	}

	/**
	 * One that internally allows that we already have a connection to work with. If the connection is null, then one will be created.
	 * 
	 * It is important that if the connection is not null, then we are in a transaction.
	 */
	private synchronized IREMBeanTypeProxy getBeanTypeProxy(String typeName, IREMConnection inConnect) throws CommandException {

		// See whether we already have the proxy for the argument name
		IProxyBeanType beanTypeProxy = (IProxyBeanType) fBeanProxies.get(typeName);
		// See if there and resolved, if so, return it. If not resolved, that means we need it NOW
		// so we must go for it. When finally resolved the original ExpressionProxy will be deregistered and
		// the resolved beantypeproxy will be in its place.
		if (beanTypeProxy != null && beanTypeProxy.isBeanProxy()) { return (IREMBeanTypeProxy) beanTypeProxy; }

		// If not an array, then see if the package extension mechanism can find it.
		// Do this here so that if it is found in the package extension we won't necessarily create an
		// extra connection when not needed.
		if (typeName.charAt(0) != '[') {
			// It is not an array
			// First check with the factory for the package of the class.
			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
			// the package ended and the class started.
			int packageIndex = typeName.lastIndexOf('.');
			if (packageIndex != -1) {
				String packageName = typeName.substring(0, packageIndex);
				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
				if (packageFactory != null) {
					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName);
					if (beanTypeProxy != null) {
						registerBeanTypeProxy((IREMBeanTypeProxy) beanTypeProxy, false);
						return (IREMBeanTypeProxy) beanTypeProxy;
					}
				}
			}
		}

		IREMConnection connect = inConnect != null ? inConnect : fFactoryRegistry.getFreeConnection();
		if (inConnect == null)
			fBeanFactory.startTransaction(); // Start a transation.
		try {
			return createBeanTypeProxy(typeName, connect);
		} catch (CommandException e) {
			if (inConnect == null) {
				// Need to close the connection, not return it.
				fFactoryRegistry.closeConnection(connect);
				connect = null; // So that it won't be returned.
			}
			throw e; // Pass it on up
		} finally {
			if (inConnect == null)
				fBeanFactory.stopTransaction();
			if (inConnect == null && connect != null)
				fFactoryRegistry.returnConnection(connect);
		}
	}

	/*
	 * It is important this be called only from within a transaction.
	 */
	private Commands.GetClassReturn getClassReturn(IREMConnection connection, String className) throws CommandException, ThrowableProxy {
		try {
			return connection.getClass(className);
		} catch (CommandErrorException e) {
			fBeanFactory.processErrorReturn(e); // Let proxy factory handle the error return
		}
		return null;
	}

	/**
	 * Return an Array type proxy for the given class name of the specified dimensions. This is a helper method. The same result can be gotton from
	 * getBeanTypeProxy. e.g. getBeanTypeProxy("java.lang.Object", 3) is the same as: getBeanTypeProxy("[[[Ljava.lang.Object;")
	 * 
	 * They both result in a type of: Object [][][]
	 * 
	 * or getBeanTypeProxy("[Ljava.langObject;", 3) becomes Object [][][][]
	 */
	public IBeanTypeProxy getBeanTypeProxy(String componentClassName, int dimensions) {
		return getBeanTypeProxy(getArrayClassName(componentClassName, dimensions));
	}

	/**
	 * @param componentClassName
	 * @param dimensions
	 * @return
	 * 
	 * @since 1.1.0
	 */
	private String getArrayClassName(String componentClassName, int dimensions) {
		String jniComponentClassName = MapTypes.getJNIFormatName(componentClassName);
		String compType = jniComponentClassName;
		if (jniComponentClassName.charAt(0) != '[') {
			// We're not already an array, so create correct template.
			compType = (String) MapTypes.MAP_TYPENAME_TO_SHORTSIG.get(jniComponentClassName);
			if (compType == null) {
				// It is a class, and not a type.
				compType = "L" + jniComponentClassName + ";"; //$NON-NLS-1$ //$NON-NLS-2$
			}
		}

		// Now create it with the appropriate number of '[' in front.
		StringBuffer buffer = new StringBuffer(dimensions + compType.length());
		for (int i = 0; i < dimensions; i++)
			buffer.append('[');
		buffer.append(compType);
		return buffer.toString();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IExpression,
	 *      java.lang.String, int)
	 */
	public IProxyBeanType getBeanTypeProxy(IExpression expression, String componentClassName, int dimensions) {
		return getBeanTypeProxy(expression, getArrayClassName(componentClassName, dimensions));
	}

	/**
	 * Get the bean type proxy from a class id. This means that a new class id was sent back from the server that we don't have yet. We need to go ask
	 * the server for information on this type so that we can create it.
	 * 
	 * NOTE: This is package protected so that only the standard bean proxy factory can call it.
	 * 
	 * It is important that this has been called within a transaction.
	 */
	IREMBeanTypeProxy createBeanTypeProxy(Integer classID) {
		IREMConnection connect = fFactoryRegistry.getFreeConnection();
		try {
			return createBeanTypeProxy(classID, connect);
		} catch (CommandException e) {
			if (e.isRecoverable()) {
				// It is recoverable, print message, keep connection live and return it.
				ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
			} else {
				// Try again, close connection, get a new one.
				fFactoryRegistry.closeConnection(connect);
				connect = null;
				connect = fFactoryRegistry.getFreeConnection();
				try {
					return createBeanTypeProxy(classID, connect);
				} catch (CommandException eAgain) {
					// Failed again. Close connection, don't return it.
					ProxyPlugin.getPlugin().getLogger().log(
							new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", eAgain)); //$NON-NLS-1$
					fFactoryRegistry.closeConnection(connect);
					connect = null;
				}
			}
		} finally {
			if (connect != null)
				fFactoryRegistry.returnConnection(connect);
		}
		return null;
	}

	/*
	 * One that internally allows that we already have a connection to work with. If the connection is null, then one will be created.
	 * 
	 * It is important this be called only from within a transaction.
	 */
	private synchronized IREMBeanTypeProxy createBeanTypeProxy(Integer classID, IREMConnection connect) throws CommandException {
		// We don't have the beantype proxy, so create it.
		IREMBeanTypeProxy beanTypeProxy = null;

		Commands.GetClassIDReturn ret = null;
		try {
			ret = getClassIDReturn(connect, classID);
		} catch (ThrowableProxy ep) {
			// Just print out the trace and return proxy not found.
			ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", ep)); //$NON-NLS-1$
			return null;
		}

		// If the signature is that of a class.
		if (ret.className.charAt(0) != '[') {
			// It is not an array.
			IREMBeanTypeProxy superTypeProxy = null;
			if (!ret.isInterface && ret.superClassname.length() != 0) {
				// Get the beantype proxy of the superclass.
				superTypeProxy = getBeanTypeProxy(ret.superClassname, connect);
			}

			// First check with the factory for the package of the class.
			// Inner classes have to use the dollar notation since if they didn't we couldn't tell where
			// the package ended and the class started.
			int packageIndex = ret.className.lastIndexOf('.');
			if (packageIndex != -1) {
				String packageName = ret.className.substring(0, packageIndex);
				IREMBeanTypeProxyFactory packageFactory = (IREMBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactoryExtension(packageName);
				if (packageFactory != null) {
					beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(ret.className, classID, superTypeProxy);
					if (beanTypeProxy != null) {
						registerBeanTypeProxy(beanTypeProxy, false);
						return beanTypeProxy;
					}
				}
			}

			if (ret.isInterface) {
				// Interface never have a super type, so we will let the object class do it for us.
				beanTypeProxy = new REMInterfaceBeanTypeProxy(fFactoryRegistry, classID, ret.className);
			} else {
				// Ask the beantype proxy of the superclass
				// to create a beantype proxy of the same beantype proxy class.
				// This is so that any subclasses will get the same beantype proxy class
				// for it if it is special.
				if (superTypeProxy != null)
					beanTypeProxy = superTypeProxy.newBeanTypeForClass(classID, ret.className, ret.isAbstract);
			}

			// Cache the instance so we can re-use it again
			if (beanTypeProxy != null)
				registerBeanTypeProxy(beanTypeProxy, false);
			return beanTypeProxy;
		} else {
			// It is an array.
			beanTypeProxy = new REMArrayBeanTypeProxy(fFactoryRegistry, classID, ret.className, objectClass);
			registerBeanTypeProxy(beanTypeProxy, false);
			return beanTypeProxy;
		}
	}

	/*
	 * It is important that this be called only from within a transaction.
	 */
	private Commands.GetClassIDReturn getClassIDReturn(IREMConnection connection, Integer classID) throws CommandException, ThrowableProxy {
		try {
			return connection.getClassFromID(classID.intValue());
		} catch (CommandErrorException e) {
			fBeanFactory.processErrorReturn(e); // Let proxy factory handle the error return
		}
		return null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registerBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IBeanTypeProxy,
	 *      boolean)
	 */
	public synchronized void registerBeanTypeProxy(IBeanTypeProxy aBeanTypeProxy, boolean permanent) {
		fBeanProxies.put(aBeanTypeProxy.getTypeName(), aBeanTypeProxy);
		fBeanFactory.registerProxy((IREMBeanProxy) aBeanTypeProxy);
		if (permanent)
			fPermanentProxies.add(aBeanTypeProxy);
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registerBeanTypeProxy(org.eclipse.jem.internal.proxy.core.IProxyBeanType,
	 *      boolean)
	 */
	public void registerBeanTypeProxy(IProxyBeanType aProxyBeanType, final boolean permanent) {
		if (aProxyBeanType.isBeanProxy())
			registerBeanTypeProxy((IBeanTypeProxy) aProxyBeanType, permanent); // A regular kind, do regular registration.
		else {
			ExpressionProxy beanExpressionProxy = ((ExpressionProxy) aProxyBeanType);
			final String typeName = aProxyBeanType.getTypeName();
			((REMExpression) beanExpressionProxy.getExpression()).addBeanType(typeName, aProxyBeanType);
			beanExpressionProxy.addProxyListener(new ExpressionProxy.ProxyAdapter() {

				public void proxyResolved(ProxyEvent event) {
					String typeName = ((IProxyBeanType) event.getSource()).getTypeName();
					synchronized (REMStandardBeanTypeProxyFactory.this) {
						if (!fBeanProxies.containsKey(typeName)) {
							// It hasn't been resolved through some other means. So this is good. Actually this should never
							// occur because upon resolution we've already registered the bean type proxy through the
							// normal mechanisms. But to be safe, we'll do it here.
							fBeanProxies.put(typeName, event.getProxy());
							if (permanent)
								fPermanentProxies.add(event.getProxy());
						}
					}
				}
				
				public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
					((REMExpression) ((ExpressionProxy) event.getSource()).getExpression()).removeBeanType(typeName);
				}
			});
		}

	}

	/**
	 * A beantype proxy is asked to be released. We can only release ones that were not in the permanent set that we initialized with. Those in the
	 * permanent set can't be changed so we can't release them.
	 * 
	 * Answer whether it can be released from the server too.
	 * 
	 * NOTE: Package protected since only REMStandardBeanProxyFactory should call it.
	 */
	boolean releaseProxy(IBeanTypeProxy proxy) {
		/**
		 * Currently we won't allow any bean type proxies to be released. We don't have a good strategy for handling that there may be hard refs from
		 * subtypes. One thought is that beanproxies table should store SoftReferences so that only when space is needed, that any beantype that
		 * doesn't have a subtype (since subtypes hold a strong ref) or, is in the permanent table (since that is hardref) could be GC'd. Then what
		 * would happen is on releaseProxy we don't actually release, we change it to a WeakRef so that it would definitely be released on a GC. These
		 * are complicated arch. and we're not sure if it should be allowed or not. So for now, we don't allow them to be released. if
		 * (!fPermanentProxies.contains(proxy)) { // We can release it. It is not one of the permanent ones. synchronized(this) {
		 * fBeanProxies.remove(proxy.getTypeName()); return true; } }
		 */
		return false;
	}

	/*
	 * Terminate this factory. Since all of the proxies are registered in the proxy factory, there is no need to release them here. There is no need
	 * to clear out any fields since this factory will not be held onto by anything and so it will be GC'd.
	 */
	public void terminateFactory(boolean wait) {
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeRegistered(String)
	 */
	public synchronized boolean isBeanTypeRegistered(String className) {
		return fBeanProxies.containsKey(MapTypes.getJNIFormatName(className));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registeredTypes()
	 */
	public Set registeredTypes() {
		return fBeanProxies.keySet();
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeNotFound(String)
	 */
	public synchronized boolean isBeanTypeNotFound(String className) {
		return fNotFoundTypes != null && fNotFoundTypes.contains(MapTypes.getJNIFormatName(className));
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isMaintainNotFoundTypes()
	 */
	public synchronized boolean isMaintainNotFoundTypes() {
		return fNotFoundTypes != null;
	}

	/*
	 * (non-Javadoc)
	 * 
	 * @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#setMaintainNotFoundTypes(boolean)
	 */
	public synchronized void setMaintainNotFoundTypes(boolean maintain) {
		if (maintain) {
			if (fNotFoundTypes == null)
				fNotFoundTypes = new HashSet();
		} else
			fNotFoundTypes = null;
	}

}