/*******************************************************************************
* 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;
/*
* $RCSfile: IDEStandardBeanTypeProxyFactory.java,v $ $Revision: 1.12 $ $Date: 2005/08/24 20:39:06 $
*/
import java.lang.reflect.Array;
import java.math.BigDecimal;
import java.math.BigInteger;
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.common.MapTypes;
import org.eclipse.jem.internal.proxy.core.*;
import org.eclipse.jem.internal.proxy.core.ExpressionProxy.ProxyEvent;
public class IDEStandardBeanTypeProxyFactory implements IStandardBeanTypeProxyFactory {
protected final IDEProxyFactoryRegistry fFactoryRegistry;
// Hashtable to cache proxies for classes so they are found on second and subsequent lookups
protected Map beanProxies;
public static Map MAP_SHORTSIG_TO_TYPE = new HashMap(8);
public static Map MAP_TYPENAME_TO_SHORTSIG = new HashMap(8);
static {
MAP_SHORTSIG_TO_TYPE.put("B", Byte.TYPE); //$NON-NLS-1$
MAP_SHORTSIG_TO_TYPE.put("C", Character.TYPE); //$NON-NLS-1$
MAP_SHORTSIG_TO_TYPE.put("D", Double.TYPE); //$NON-NLS-1$
MAP_SHORTSIG_TO_TYPE.put("F", Float.TYPE); //$NON-NLS-1$
MAP_SHORTSIG_TO_TYPE.put("I", Integer.TYPE); //$NON-NLS-1$
MAP_SHORTSIG_TO_TYPE.put("J", Long.TYPE); //$NON-NLS-1$
MAP_SHORTSIG_TO_TYPE.put("S", Short.TYPE); //$NON-NLS-1$
MAP_SHORTSIG_TO_TYPE.put("Z", Boolean.TYPE); //$NON-NLS-1$
MAP_TYPENAME_TO_SHORTSIG.put("byte", "B"); //$NON-NLS-1$ //$NON-NLS-2$
MAP_TYPENAME_TO_SHORTSIG.put("char", "C"); //$NON-NLS-1$ //$NON-NLS-2$
MAP_TYPENAME_TO_SHORTSIG.put("double", "D"); //$NON-NLS-1$ //$NON-NLS-2$
MAP_TYPENAME_TO_SHORTSIG.put("float", "F"); //$NON-NLS-1$ //$NON-NLS-2$
MAP_TYPENAME_TO_SHORTSIG.put("int", "I"); //$NON-NLS-1$ //$NON-NLS-2$
MAP_TYPENAME_TO_SHORTSIG.put("long", "J"); //$NON-NLS-1$ //$NON-NLS-2$
MAP_TYPENAME_TO_SHORTSIG.put("short", "S"); //$NON-NLS-1$ //$NON-NLS-2$
MAP_TYPENAME_TO_SHORTSIG.put("boolean", "Z"); //$NON-NLS-1$ //$NON-NLS-2$
}
// Cached copy of a few typical bean type proxies.
IDEBeanTypeProxy objectClass;
IDEBooleanTypeBeanTypeProxy booleanType;
IDEBooleanClassBeanTypeProxy booleanClass;
IDEIntegerTypeBeanTypeProxy intType;
IDEIntegerClassBeanTypeProxy integerClass;
IDEFloatTypeBeanTypeProxy floatType;
IDEFloatClassBeanTypeProxy floatClass;
IDELongTypeBeanTypeProxy longType;
IDELongClassBeanTypeProxy longClass;
IDEShortTypeBeanTypeProxy shortType;
IDEShortClassBeanTypeProxy shortClass;
IDEByteTypeBeanTypeProxy byteType;
IDEByteClassBeanTypeProxy byteClass;
IDECharTypeBeanTypeProxy charType;
IDECharacterClassBeanTypeProxy charClass;
IDEDoubleTypeBeanTypeProxy doubleType;
IDEDoubleClassBeanTypeProxy doubleClass;
IDEStringBeanTypeProxy stringClass;
IDEClassBeanTypeProxy classClass;
IDEBeanTypeProxy voidType;
public IDEStandardBeanTypeProxyFactory(IDEProxyFactoryRegistry aRegistry) {
fFactoryRegistry = aRegistry;
aRegistry.registerBeanTypeProxyFactory(this);
// Now initialize the cache.
objectClass = new IDEBeanTypeProxy(fFactoryRegistry, Object.class);
booleanType = new IDEBooleanTypeBeanTypeProxy(fFactoryRegistry, Boolean.TYPE);
booleanClass = new IDEBooleanClassBeanTypeProxy(fFactoryRegistry, Boolean.class);
intType = new IDEIntegerTypeBeanTypeProxy(fFactoryRegistry, Integer.TYPE);
integerClass = new IDEIntegerClassBeanTypeProxy(fFactoryRegistry, Integer.class);
floatType = new IDEFloatTypeBeanTypeProxy(fFactoryRegistry, Float.TYPE);
floatClass = new IDEFloatClassBeanTypeProxy(fFactoryRegistry, Float.class);
longType = new IDELongTypeBeanTypeProxy(fFactoryRegistry, Long.TYPE);
longClass = new IDELongClassBeanTypeProxy(fFactoryRegistry, Long.class);
shortType = new IDEShortTypeBeanTypeProxy(fFactoryRegistry, Short.TYPE);
shortClass = new IDEShortClassBeanTypeProxy(fFactoryRegistry, Short.class);
byteType = new IDEByteTypeBeanTypeProxy(fFactoryRegistry, Byte.TYPE);
byteClass = new IDEByteClassBeanTypeProxy(fFactoryRegistry, Byte.class);
charType = new IDECharTypeBeanTypeProxy(fFactoryRegistry, Character.TYPE);
charClass = new IDECharacterClassBeanTypeProxy(fFactoryRegistry, Character.class);
doubleType = new IDEDoubleTypeBeanTypeProxy(fFactoryRegistry, Double.TYPE);
doubleClass = new IDEDoubleClassBeanTypeProxy(fFactoryRegistry, Double.class);
stringClass = new IDEStringBeanTypeProxy(fFactoryRegistry, String.class);
classClass = new IDEClassBeanTypeProxy(fFactoryRegistry, java.lang.Class.class);
voidType = new IDEBeanTypeProxy(fFactoryRegistry, Void.TYPE);
// Initialize the hashtable with the primitives, their lang equivalents, and also common classes like String
beanProxies = new HashMap(20);
// Primitives
beanProxies.put(intType.getTypeName(), intType);
beanProxies.put(booleanType.getTypeName(), booleanType);
beanProxies.put(charType.getTypeName(), charType);
beanProxies.put(byteType.getTypeName(), byteType);
beanProxies.put(shortType.getTypeName(), shortType);
beanProxies.put(longType.getTypeName(), longType);
beanProxies.put(floatType.getTypeName(), floatType);
beanProxies.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
beanProxies.put(integerClass.getTypeName(), integerClass);
beanProxies.put(booleanClass.getTypeName(), booleanClass);
beanProxies.put(charClass.getTypeName(), charClass);
beanProxies.put(byteClass.getTypeName(), byteClass);
beanProxies.put(shortClass.getTypeName(), shortClass);
beanProxies.put(longClass.getTypeName(), longClass);
beanProxies.put(floatClass.getTypeName(), floatClass);
beanProxies.put(doubleClass.getTypeName(), doubleClass);
beanProxies.put(BigDecimal.class.getName(), new IDEBigDecimalBeanTypeProxy(fFactoryRegistry, BigDecimal.class));//$NON-NLS-1$
beanProxies.put(BigInteger.class.getName(), new IDEBigIntegerBeanTypeProxy(fFactoryRegistry, BigInteger.class));//$NON-NLS-1$
beanProxies.put(stringClass.getTypeName(), stringClass);
beanProxies.put(classClass.getTypeName(), classClass);
beanProxies.put(voidType.getTypeName(), voidType);
}
/**
* We are an IDE proxy and know that the type is in the same VM as the IDE. the IDEBeanTypeProxy object NOTE This is package protected because the
* only person who can call it are priveledged classes that are also creating things in an IDEProxy environment. If anyone needs to make this
* method public they are doing the wrong thing as they should use the public method getBeanTypeProxy(String) that is on the interface. The only
* other object that can guarantee that they have the class for the argument are those that are part of the idevm package
*/
IBeanTypeProxy getBeanTypeProxy(Class anIDEClass) {
return getBeanTypeProxy(anIDEClass.getName());
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(java.lang.String)
*/
public synchronized IBeanTypeProxy getBeanTypeProxy(String typeName) {
typeName = MapTypes.getJNIFormatName(typeName);
// See whether we already have the proxy for the argument name
IProxyBeanType beanTypeProxy = (IProxyBeanType) beanProxies.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 (IBeanTypeProxy) 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);
IDEExtensionBeanTypeProxyFactory packageFactory = (IDEExtensionBeanTypeProxyFactory) fFactoryRegistry
.getBeanTypeProxyFactoryExtension(packageName);
if (packageFactory != null) {
beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName);
if (beanTypeProxy != null) {
registerBeanTypeProxy((IBeanTypeProxy) beanTypeProxy, false);
return (IBeanTypeProxy) beanTypeProxy;
}
}
}
// There was not a registered factory that dealt with the class. Load it using the factory
// registry which has the plugin's class loader
try {
Class ideClass = fFactoryRegistry.loadClass(typeName);
IDEBeanTypeProxy superTypeProxy = null;
if (ideClass.getSuperclass() != null) {
// Get the beantype proxy of the superclass.
superTypeProxy = (IDEBeanTypeProxy) getBeanTypeProxy(ideClass.getSuperclass());
}
// 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(ideClass);
if (beanTypeProxy == null)
beanTypeProxy = new IDEBeanTypeProxy(fFactoryRegistry, ideClass);
} catch (ClassNotFoundException e) {
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.INFO, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
String msg = MessageFormat.format("{0}({1})", new Object[] { e.getClass(), e.getMessage()}); //$NON-NLS-1$
beanTypeProxy = new IDEInitErrorBeanTypeProxy(fFactoryRegistry, typeName, msg, e);
} catch (ExceptionInInitializerError e) {
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
String msg = MessageFormat.format("{0}({1})", new Object[] { e.getClass(), e.getMessage()}); //$NON-NLS-1$
beanTypeProxy = new IDEInitErrorBeanTypeProxy(fFactoryRegistry, typeName, msg, e.getCause());
} catch (LinkageError e) {
ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e)); //$NON-NLS-1$
String msg = MessageFormat.format("{0}({1})", new Object[] { e.getClass(), e.getMessage()}); //$NON-NLS-1$
beanTypeProxy = new IDEInitErrorBeanTypeProxy(fFactoryRegistry, typeName, msg, e);
}
// Cache the instance so we can re-use it again
beanProxies.put(typeName, beanTypeProxy);
return (IBeanTypeProxy) beanTypeProxy;
} else {
// need to create a array of this many dimensions so that we can get the appropriate class for it.
int dims = typeName.lastIndexOf('[') + 1;
Class finalComponentType = null;
if (typeName.charAt(dims) == 'L') {
// It is a class.
// Strip off up to the 'L', and the trailing ';'. That is the class name.
IDEBeanTypeProxy finalType = (IDEBeanTypeProxy) getBeanTypeProxy(typeName.substring(dims + 1, typeName.length() - 1));
if (finalType != null)
finalComponentType = finalType.fClass;
} else {
// It is a type. Need to map it.
finalComponentType = (Class) IDEStandardBeanTypeProxyFactory.MAP_SHORTSIG_TO_TYPE.get(typeName.substring(dims, dims + 1));
}
if (finalComponentType != null) {
Object dummyArray = Array.newInstance(finalComponentType, new int[dims]);
beanTypeProxy = new IDEArrayBeanTypeProxy(fFactoryRegistry, typeName, dummyArray.getClass());
beanProxies.put(typeName, beanTypeProxy);
}
return (IBeanTypeProxy) beanTypeProxy;
}
}
/*
* (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) beanProxies.get(typeName);
if (beanTypeProxy != null) { return beanTypeProxy; }
// Now see if an expression proxy cached.
beanTypeProxy = ((IDEExpression) 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);
IDEExtensionBeanTypeProxyFactory packageFactory = (IDEExtensionBeanTypeProxyFactory) fFactoryRegistry
.getBeanTypeProxyFactoryExtension(packageName);
if (packageFactory != null) {
beanTypeProxy = packageFactory.getExtensionBeanTypeProxy(typeName, expression);
if (beanTypeProxy != null) {
registerBeanTypeProxy(beanTypeProxy, false);
return beanTypeProxy;
}
}
}
}
// There was not a registered factory that dealt with the class. So create the expression proxy.
beanTypeProxy = ((Expression) expression).createBeanTypeExpressionProxy(typeName);
registerBeanTypeProxy(beanTypeProxy, false);
return beanTypeProxy;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#getBeanTypeProxy(java.lang.String, int)
*/
public IBeanTypeProxy getBeanTypeProxy(String componentClassName, int dimensions) {
return getBeanTypeProxy(getArrayClassname(componentClassName, dimensions));
}
/*
* (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));
}
/**
* @param componentClassName
* @param dimensions
* @return
*
* @since 1.1.0
*/
protected String getArrayClassname(String componentClassName, int dimensions) {
String jniComponentTypeName = MapTypes.getJNIFormatName(componentClassName);
String compType = jniComponentTypeName;
if (jniComponentTypeName.charAt(0) != '[') {
// We're not already an array, so create correct template.
compType = (String) MAP_TYPENAME_TO_SHORTSIG.get(componentClassName);
if (compType == null) {
// It is a class, and not a type.
compType = "L" + jniComponentTypeName + ";"; //$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.IBeanProxyFactory#terminateFactory(boolean)
*/
public void terminateFactory(boolean wait) {
}
/*
* (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) {
beanProxies.put(aBeanTypeProxy.getTypeName(), 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, 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();
((IDEExpression) beanExpressionProxy.getExpression()).addBeanType(typeName, aProxyBeanType);
beanExpressionProxy.addProxyListener(new ExpressionProxy.ProxyAdapter() {
public void proxyResolved(ProxyEvent event) {
String typeName = ((IProxyBeanType) event.getSource()).getTypeName();
synchronized (IDEStandardBeanTypeProxyFactory.this) {
if (!beanProxies.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.
beanProxies.put(typeName, event.getProxy());
}
}
}
public void proxyNotResolved(ExpressionProxy.ProxyEvent event) {
((IDEExpression) ((ExpressionProxy) event.getSource()).getExpression()).removeBeanType(typeName);
}
});
}
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeRegistered(String)
*/
public synchronized boolean isBeanTypeRegistered(String className) {
return beanProxies.containsKey(MapTypes.getJNIFormatName(className));
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#registeredTypes()
*/
public Set registeredTypes() {
return beanProxies.keySet();
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isBeanTypeNotFound(String)
*/
public boolean isBeanTypeNotFound(String className) {
// Do nothing. No need for it in IDE system because there will always be a proxy, even when not found.
// In that case an IDEInitErrorBeanTypeProxy will be created.
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#isMaintainNotFoundTypes()
*/
public boolean isMaintainNotFoundTypes() {
// Do nothing. No need for it in IDE system because there will always be a proxy, even when not found.
// In that case an IDEInitErrorBeanTypeProxy will be created.
return false;
}
/*
* (non-Javadoc)
*
* @see org.eclipse.jem.internal.proxy.core.IStandardBeanTypeProxyFactory#setMaintainNotFoundTypes(boolean)
*/
public void setMaintainNotFoundTypes(boolean maintain) {
// Do nothing. No need for it in IDE system because there will always be a proxy, even when not found.
// In that case an IDEInitErrorBeanTypeProxy will be created.
}
}