| /******************************************************************************* |
| * 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.lang.reflect.AccessibleObject; |
| |
| 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.common.remote.Commands; |
| import org.eclipse.jem.internal.proxy.common.remote.TransmitableArray; |
| |
| /** |
| * Factory for creating method proxies. Creation date: (12/3/99 6:29:40 PM) |
| * |
| * @author: Joe Winchester |
| */ |
| public class REMMethodProxyFactory implements IMethodProxyFactory { |
| |
| final protected REMProxyFactoryRegistry fFactoryRegistry; |
| |
| // Cached copy of a few typical method type proxies. |
| IREMBeanTypeProxy accessibleType; |
| |
| REMMethodTypeProxy methodType; |
| |
| REMFieldTypeProxy fieldType; |
| |
| REMConstructorTypeProxy ctorType; |
| |
| REMMethodProxy getMethodProxy; |
| |
| REMMethodProxyFactory(REMProxyFactoryRegistry aRegistry) { |
| fFactoryRegistry = aRegistry; |
| aRegistry.registerMethodProxyFactory(this); |
| REMStandardBeanTypeProxyFactory typeFactory = (REMStandardBeanTypeProxyFactory) aRegistry.getBeanTypeProxyFactory(); |
| |
| accessibleType = typeFactory.objectClass.newBeanTypeForClass(new Integer(Commands.ACCESSIBLEOBJECT_CLASS), AccessibleObject.class.getName(), |
| false); |
| methodType = new REMMethodTypeProxy(aRegistry, accessibleType); |
| fieldType = new REMFieldTypeProxy(aRegistry, accessibleType); |
| ctorType = new REMConstructorTypeProxy(aRegistry, accessibleType); |
| aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(accessibleType, true); |
| aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(methodType, true); |
| aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(fieldType, true); |
| aRegistry.getBeanTypeProxyFactory().registerBeanTypeProxy(ctorType, true); |
| |
| getMethodProxy = (REMMethodProxy) methodType.newBeanProxy(new Integer(Commands.GET_METHOD_ID)); |
| ((REMStandardBeanProxyFactory) aRegistry.getBeanProxyFactory()).registerProxy(getMethodProxy); |
| |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getMethodProxy(java.lang.String, java.lang.String, java.lang.String[]) |
| */ |
| public IMethodProxy getMethodProxy(String className, String methodName, String[] parameterTypes) { |
| IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory(); |
| IBeanTypeProxy clsProxy = typeFactory.getBeanTypeProxy(className); |
| if (clsProxy == null) |
| return null; |
| // This will redirect to the beantype, which will go through the method cache. |
| return clsProxy.getMethodProxy(methodName, parameterTypes); |
| } |
| |
| /** |
| * A helper method to get the method proxy for the expression. This is used by registries and beantype proxies. It will go through |
| * the method cache to make sure we get only one. |
| * |
| * @param expression |
| * @param aBeanTypeProxy |
| * @param methodName |
| * @param parmTypes |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| public IProxyMethod getMethodProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, String methodName, IProxyBeanType[] parmTypes){ |
| return ((REMStandardBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactory()).proxyConstants.getMethodProxy(expression, aBeanTypeProxy, methodName, parmTypes); |
| } |
| |
| /** |
| * A helper method to get the field proxy for the expression. This is used by registries and beantype proxies. It will go through |
| * the method cache to make sure we get only one. |
| * @param expression |
| * @param aBeanTypeProxy |
| * @param fieldName |
| * |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| public IProxyField getFieldProxy(IExpression expression, IProxyBeanType aBeanTypeProxy, String fieldName){ |
| return ((REMStandardBeanTypeProxyFactory) fFactoryRegistry.getBeanTypeProxyFactory()).proxyConstants.getFieldProxy(expression, aBeanTypeProxy, fieldName); |
| } |
| |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getFieldProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String) |
| */ |
| public IProxyField getFieldProxy(IExpression expression, String className, String fieldName) { |
| // We are getting the class resolved through the expression. Might as well because it probably will |
| // be needed again and this way when the expression is finished it will be resolved for later usage. |
| IStandardBeanTypeProxyFactory beanTypeProxyFactory = fFactoryRegistry.getBeanTypeProxyFactory(); |
| IProxyBeanType beanType = beanTypeProxyFactory.getBeanTypeProxy(expression, className); |
| return beanType.getFieldProxy(expression, fieldName); |
| } |
| |
| /* (non-Javadoc) |
| * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getMethodProxy(org.eclipse.jem.internal.proxy.core.IExpression, java.lang.String, java.lang.String, java.lang.String[]) |
| */ |
| public IProxyMethod getMethodProxy(IExpression expression, String className, String methodName, String[] parameterTypes) { |
| // We are getting the class and parmtypes resolved through the expression. Might as well because they probably will |
| // be needed again and this way when the expression is finished they will be resolved for later usage. |
| IStandardBeanTypeProxyFactory beanTypeProxyFactory = fFactoryRegistry.getBeanTypeProxyFactory(); |
| IProxyBeanType beanType = beanTypeProxyFactory.getBeanTypeProxy(expression, className); |
| IProxyBeanType[] parmTypes = getParameterTypes(expression, parameterTypes, beanTypeProxyFactory); |
| return beanType.getMethodProxy(expression, methodName, parmTypes); |
| } |
| |
| /** |
| * Helper method for BeanTypes and proxy Beantypes. So they don't need to have common code to convert string to proxy bean type. |
| * @param expression |
| * @param classType |
| * @param methodName |
| * @param parameterTypes |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| public IProxyMethod getMethodProxy(IExpression expression, IProxyBeanType classType, String methodName, String[] parameterTypes) { |
| // We are getting the class and parmtypes resolved through the expression. Might as well because they probably will |
| // be needed again and this way when the expression is finished they will be resolved for later usage. |
| IStandardBeanTypeProxyFactory beanTypeProxyFactory = fFactoryRegistry.getBeanTypeProxyFactory(); |
| IProxyBeanType[] parmTypes = getParameterTypes(expression, parameterTypes, beanTypeProxyFactory); |
| return classType.getMethodProxy(expression, methodName, parmTypes); |
| } |
| |
| /** |
| * @param expression |
| * @param parameterTypes |
| * @param beanTypeProxyFactory |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| protected IProxyBeanType[] getParameterTypes(IExpression expression, String[] parameterTypes, IStandardBeanTypeProxyFactory beanTypeProxyFactory) { |
| IProxyBeanType[] parmTypes; |
| if (parameterTypes == null || parameterTypes.length == 0) |
| parmTypes = null; |
| else { |
| parmTypes = new IProxyBeanType[parameterTypes.length]; |
| for (int i = 0; i < parameterTypes.length; i++) { |
| parmTypes[i] = beanTypeProxyFactory.getBeanTypeProxy(expression, parameterTypes[i]); |
| } |
| } |
| return parmTypes; |
| } |
| |
| /* |
| * (non-Javadoc) |
| * |
| * @see org.eclipse.jem.internal.proxy.core.IMethodProxyFactory#getInvokable(java.lang.String, java.lang.String, java.lang.String[]) |
| */ |
| public IInvokable getInvokable(String className, String methodName, String[] parameterTypes) { |
| IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory(); |
| IBeanTypeProxy clsProxy = typeFactory.getBeanTypeProxy(className); |
| if (clsProxy == null) |
| return null; |
| return clsProxy.getInvokable(methodName, parameterTypes); |
| } |
| |
| /** |
| * Get the method id from the remote system and create the method proxy. |
| * |
| * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else. |
| * |
| * @param beanType |
| * @param methodName |
| * @param parameterTypes |
| * @return |
| * |
| * @since 1.0.0 |
| */ |
| public IInvokable getInvokable(IREMBeanTypeProxy beanType, String methodName, String[] parameterTypes) { |
| // First convert the parameter types into IBeanTypeProxy[]. |
| IREMBeanTypeProxy[] types = null; |
| if (parameterTypes != null) { |
| IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory(); |
| types = new IREMBeanTypeProxy[parameterTypes.length]; |
| for (int i = 0; i < parameterTypes.length; i++) { |
| IBeanTypeProxy type = types[i] = (IREMBeanTypeProxy) typeFactory.getBeanTypeProxy(parameterTypes[i]); |
| if (type == null) |
| return null; // One of the parm types doesn't exist. |
| } |
| } |
| |
| return getInvokable(beanType, methodName, types); |
| } |
| |
| /** |
| * Get the method id from the remote system and create the method proxy. |
| * This does not go through the method cache. It goes direct to the remote vm. |
| * |
| * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else. |
| */ |
| public IMethodProxy getMethodProxy(IREMBeanTypeProxy beanType, String methodName, String[] parameterTypes) { |
| // First convert the parameter types into IBeanTypeProxy[]. |
| IBeanTypeProxy[] types = null; |
| if (parameterTypes != null) { |
| IStandardBeanTypeProxyFactory typeFactory = fFactoryRegistry.getBeanTypeProxyFactory(); |
| types = new IBeanTypeProxy[parameterTypes.length]; |
| for (int i = 0; i < parameterTypes.length; i++) { |
| IBeanTypeProxy type = types[i] = typeFactory.getBeanTypeProxy(parameterTypes[i]); |
| if (type == null) |
| return null; // One of the parm types doesn't exist. |
| } |
| } |
| |
| return getMethodProxy(beanType, methodName, types); |
| } |
| |
| |
| /** |
| * Get the invokable. |
| * |
| * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else. |
| * @param beanType |
| * @param methodName |
| * @param parameterTypes |
| * @return |
| * |
| * @since 1.0.0 |
| */ |
| public IInvokable getInvokable(IREMBeanTypeProxy beanType, String methodName, IBeanTypeProxy[] parameterTypes) { |
| return new REMInvokable(beanType, methodName, parameterTypes); |
| } |
| |
| /** |
| * Get the method id from the remote system and create the method proxy. |
| * <p> |
| * This does not go through the method cache. It goes direct to the remote vm. |
| * |
| * NOTE: It is public ONLY so that IBeanTypeProxy implementations can call it. It must not be used by anyone else. |
| */ |
| public IMethodProxy getMethodProxy(IREMBeanTypeProxy beanType, String methodName, IBeanTypeProxy[] parameterTypes) { |
| // The parms to getMethod are: |
| // parm[0] = String - method name |
| // parm[1] = Class[] - Parameter Classes. |
| Object[] parms = new Object[] { methodName, parameterTypes != null ? (new TransmitableArray(Commands.CLASS_CLASS, parameterTypes)) : null}; |
| IBeanProxy result = null; |
| try { |
| result = getMethodProxy.invokeWithParms(beanType, parms); |
| return (IMethodProxy) result; |
| } catch (ThrowableProxy e) { |
| fFactoryRegistry.releaseProxy(e); // Since it's not needed, get rid of now instead of GC time. |
| return null; |
| } catch (ClassCastException e) { |
| // Some trace msgs because we keep getting into a mode after awhile (though not reproducible) that returns non-method proxies and we need |
| // more info. |
| StringBuffer buf = new StringBuffer("Method requested is \"" + methodName + "("); //$NON-NLS-1$ //$NON-NLS-2$ |
| for (int i = 0; i < parameterTypes.length; i++) { |
| if (i > 0) |
| buf.append(','); //$NON-NLS-1$ |
| buf.append(parameterTypes[i].getTypeName()); |
| } |
| buf.append(")\""); //$NON-NLS-1$ |
| ProxyPlugin.getPlugin().getLogger().log( |
| new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, buf.toString(), null)); |
| try { |
| if (result != null) { |
| ProxyPlugin.getPlugin().getLogger().log( |
| new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, |
| "ClassCastException of result. Return type is \"" + result.getTypeProxy().getTypeName() + "\"\n" + //$NON-NLS-1$ //$NON-NLS-2$ |
| "Return type bean type proxy class=\"" + result.getTypeProxy().getClass().getName() + "\"\n" + //$NON-NLS-1$ //$NON-NLS-2$ |
| "GetMethodProxy valid=" + getMethodProxy.isValid() + "\n" + //$NON-NLS-1$ //$NON-NLS-2$ |
| "GetMethodProxy real name is \"" + getMethodProxy.getName() + "\"\n", null)); //$NON-NLS-1$ //$NON-NLS-2$ |
| } |
| } catch (Exception e2) { |
| ProxyPlugin.getPlugin().getLogger().log(new Status(IStatus.ERROR, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", e2)); //$NON-NLS-1$ |
| } |
| throw e; // Rethrow it. |
| } |
| } |
| |
| /* |
| * Terminate the factory. Don't need to do anything because of the proxies being held onto are registered any will be cleaned up themselves. |
| */ |
| public void terminateFactory(boolean wait) { |
| } |
| |
| } |
