| /******************************************************************************* |
| * 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.lang.reflect.InvocationTargetException; |
| import java.lang.reflect.Method; |
| |
| import org.eclipse.core.runtime.IStatus; |
| import org.eclipse.core.runtime.Status; |
| |
| import org.eclipse.jem.internal.proxy.core.*; |
| |
| public class IDEMethodProxy extends IDEAccessibleObjectProxy implements IMethodProxy { |
| |
| protected IDEMethodProxy(IDEProxyFactoryRegistry aRegistry, Method aMethod) { |
| super(aRegistry, aMethod); |
| } |
| |
| public IBeanTypeProxy getClassType() { |
| return ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy( |
| ((Method) getBean()).getDeclaringClass()); |
| } |
| public IBeanTypeProxy getReturnType() { |
| return ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy( |
| ((Method) getBean()).getReturnType()); |
| } |
| public IBeanTypeProxy[] getParameterTypes() { |
| Class[] parmClasses = ((Method) getBean()).getParameterTypes(); |
| IBeanTypeProxy[] parmTypes = new IBeanTypeProxy[parmClasses.length]; |
| IDEStandardBeanTypeProxyFactory factory = (IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory(); |
| for (int i = 0; i < parmClasses.length; i++) { |
| parmTypes[i] = factory.getBeanTypeProxy(parmClasses[i]); |
| } |
| return parmTypes; |
| } |
| public String getName() { |
| return ((Method) getBean()).getName(); |
| } |
| |
| /** |
| * The type proxy is constant proxy out of the method factory. |
| */ |
| public IBeanTypeProxy getTypeProxy() { |
| return ((IDEMethodProxyFactory) fProxyFactoryRegistry.getMethodProxyFactory()).methodType; |
| } |
| |
| /** |
| * Invoke the method directly. Because we are an IDEMethodProxy we can assume that IBeanProxy |
| * is an IDEBeanProxy and we can get its bean directly |
| */ |
| public IBeanProxy invoke(IBeanProxy subject) throws ThrowableProxy { |
| try { |
| Object result = ((Method) getBean()).invoke(subject != null ? ((IIDEBeanProxy) subject).getBean() : null, new Object[0]); |
| if (result == null) { |
| return null; |
| } else { |
| // The result may be a java.lang.Integer when we really want to create an int |
| // Reflection always give you the big object |
| Class returnType = ((Method) getBean()).getReturnType(); |
| return getBeanProxy(returnType, result); |
| } |
| } catch (InvocationTargetException e) { |
| // This is a wrappered exception. Return the wrappered one so it looks like |
| // it was the real one. |
| IBeanTypeProxy exceptionTypeProxy = |
| ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy( |
| e.getTargetException().getClass()); |
| throw new IDEThrowableProxy(e.getTargetException(), exceptionTypeProxy); |
| } catch (Exception exc) { |
| IBeanTypeProxy exceptionTypeProxy = |
| ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(exc.getClass()); |
| throw new IDEThrowableProxy(exc, exceptionTypeProxy); |
| } |
| } |
| /** |
| * Do not throw an exception |
| */ |
| public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject) { |
| try { |
| return invoke(subject); |
| } catch (ThrowableProxy exc) { |
| ProxyPlugin.getPlugin().getLogger().log( |
| new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$ |
| } |
| return null; |
| } |
| /** |
| * Invoke the method with argument. The argument will be an IDEBeanProxy |
| * ( because we are an IDEMethodProxy ) so we can cast to it and get the actual bean |
| * itself and use this to invoke against method which is the actual |
| * java.lang.Reflect instance |
| */ |
| public IBeanProxy invoke(IBeanProxy subject, IBeanProxy argument) throws ThrowableProxy { |
| try { |
| Object result = |
| ((Method) getBean()).invoke( |
| subject != null ? ((IIDEBeanProxy) subject).getBean() : null, |
| new Object[] { argument != null ? ((IIDEBeanProxy) argument).getBean() : null }); |
| if (result == null) { |
| return null; |
| } else { |
| Class returnType = ((Method) getBean()).getReturnType(); |
| return getBeanProxy(returnType, result); |
| } |
| } catch (InvocationTargetException e) { |
| // This is a wrappered exception. Return the wrappered one so it looks like |
| // it was the real one. |
| IBeanTypeProxy exceptionTypeProxy = |
| ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy( |
| e.getTargetException().getClass()); |
| throw new IDEThrowableProxy(e.getTargetException(), exceptionTypeProxy); |
| } catch (Exception exc) { |
| IBeanTypeProxy exceptionTypeProxy = |
| ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(exc.getClass()); |
| throw new IDEThrowableProxy(exc, exceptionTypeProxy); |
| } |
| } |
| /** |
| * Invoke without throwing an exception |
| */ |
| public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy argument) { |
| try { |
| return invoke(subject, argument); |
| } catch (ThrowableProxy exc) { |
| ProxyPlugin.getPlugin().getLogger().log( |
| new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$ |
| } |
| return null; |
| } |
| /** |
| * Invoke the method with arguments. The arguments will be IDEBeanProxy objects |
| * ( because we are an IDEMethodProxy ) so we can cast to them and get the actual bean |
| * objects themselves and use these to invoke against method which is the actual |
| * java.lang.Reflect instance |
| */ |
| public IBeanProxy invoke(IBeanProxy subject, IBeanProxy[] arguments) throws ThrowableProxy { |
| Object[] beanArguments = new Object[arguments.length]; |
| for (int i = 0; i < arguments.length; i++) { |
| if (arguments[i] != null) { |
| beanArguments[i] = ((IIDEBeanProxy) arguments[i]).getBean(); |
| } |
| } |
| try { |
| Object result = ((Method) getBean()).invoke(subject != null ? ((IIDEBeanProxy) subject).getBean() : null, beanArguments); |
| if (result == null) { |
| return null; |
| } else { |
| Class returnType = ((Method) getBean()).getReturnType(); |
| return getBeanProxy(returnType, result); |
| } |
| } catch (InvocationTargetException e) { |
| // This is a wrappered exception. Return the wrappered one so it looks like |
| // it was the real one. |
| IBeanTypeProxy exceptionTypeProxy = |
| ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy( |
| e.getTargetException().getClass()); |
| throw new IDEThrowableProxy(e.getTargetException(), exceptionTypeProxy); |
| } catch (Exception exc) { |
| IBeanTypeProxy exceptionTypeProxy = |
| ((IDEStandardBeanTypeProxyFactory) fProxyFactoryRegistry.getBeanTypeProxyFactory()).getBeanTypeProxy(exc.getClass()); |
| throw new IDEThrowableProxy(exc, exceptionTypeProxy); |
| } |
| } |
| /** |
| * Invoke without throwing an exception |
| */ |
| public IBeanProxy invokeCatchThrowableExceptions(IBeanProxy subject, IBeanProxy[] arguments) { |
| try { |
| return invoke(subject, arguments); |
| } catch (ThrowableProxy exc) { |
| ProxyPlugin.getPlugin().getLogger().log( |
| new Status(IStatus.WARNING, ProxyPlugin.getPlugin().getBundle().getSymbolicName(), 0, "", exc)); //$NON-NLS-1$ |
| } |
| return null; |
| } |
| IBeanProxy getBeanProxy(Class returnType, Object bean) { |
| return fProxyFactoryRegistry.getBeanProxy(returnType, bean); |
| } |
| } |