| /******************************************************************************* |
| * Copyright (c) 2001, 2006 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.core; |
| |
| import org.eclipse.jem.internal.proxy.common.AmbiguousMethodException; |
| |
| /** |
| * A proxy for a BeanType (i.e. Java type/class). Creation date: (12/3/99 11:38:06 AM) |
| * |
| * @author: Joe Winchester |
| */ |
| public interface IBeanTypeProxy extends IBeanProxy, IProxyBeanType { |
| |
| /** |
| * Find the most compatible constructor (out of the declared constructors). This means it will |
| * find either an exact match or an override that is compatible, e.g. X(Object j) is returned when looking with arg type of "java.lang.String". |
| * @param argumentTypes array of arg types or <code>null</code> if none. (In case of null, this is the default ctor, so just use that). |
| * @return |
| * @throws NoSuchMethodException |
| * @throws AmbiguousMethodException |
| * @throws IllegalAccessException |
| * |
| * @since 1.1.0 |
| */ |
| public IConstructorProxy getCompatibleConstructor(IBeanTypeProxy[] argumentTypes) throws AmbiguousMethodException, NoSuchMethodException, IllegalAccessException; |
| |
| /** |
| * Find the most compatible public method, including inheritied. This means it will |
| * find either an exact match or an override that is compatible, e.g. xyz(Object j) is returned when looking with arg type of "java.lang.String". |
| * @param methodName |
| * @param argumentTypes array of arg types or <code>null</code> if none. (In case of null, just use getMethod(String methodName) since only one is compatible then. |
| * @return |
| * @throws AmbiguousMethodException |
| * @throws NoSuchMethodException |
| * |
| * @since 1.1.0 |
| */ |
| public IMethodProxy getCompatibleMethod(String methodName, IBeanTypeProxy[] argumentTypes) throws AmbiguousMethodException, NoSuchMethodException; |
| |
| /** |
| * Return the constructor proxy on the receiver with the specified arguments Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IConstructorProxy getConstructorProxy(String[] argumentClassNames); |
| |
| /** |
| * Return the constructor proxy on the receiver with the specified types Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IConstructorProxy getConstructorProxy(IBeanTypeProxy[] argumentTypes); |
| |
| /** |
| * Return an array of public constructors for this class. |
| * |
| * @return an array of constructor proxies or <code>null</code> if an error. |
| * |
| * @since 1.1.0 |
| */ |
| public IConstructorProxy[] getConstructors(); |
| |
| /** |
| * Return the declared constructor proxy on the receiver with the specified arguments Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IConstructorProxy getDeclaredConstructorProxy(String[] argumentClassNames); |
| |
| /** |
| * Return the declared constructor proxy on the receiver with the specified types Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IConstructorProxy getDeclaredConstructorProxy(IBeanTypeProxy[] argumentTypes); |
| |
| /** |
| * Return an array of declared constructors for this class. |
| * |
| * @return an array of constructor proxies or <code>null</code> if an error. |
| * |
| * @since 1.1.0 |
| */ |
| public IConstructorProxy[] getDeclaredConstructors(); |
| |
| /** |
| * Return the array of field proxies. |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| public IFieldProxy[] getFields(); |
| |
| /** |
| * Return the array of declared field proxies. |
| * @return |
| * |
| * @since 1.1.0 |
| */ |
| public IFieldProxy[] getDeclaredFields(); |
| |
| /** |
| * Return the fieldproxy on the receiver with the specified name Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IFieldProxy getFieldProxy(String fieldName); |
| |
| /** |
| * Return the declared fieldproxy on the receiver with the specified name |
| */ |
| public IFieldProxy getDeclaredFieldProxy(String fieldName); |
| |
| /** |
| * Return the method proxy on the receiver with the specified name and no arguments. |
| * |
| * @param methodName |
| * @return |
| * @since 1.0.0 |
| */ |
| public IMethodProxy getMethodProxy(String methodName); |
| |
| /** |
| * Return the method proxy on the receiver with the qualified class names as string arguments |
| * |
| * @param methodName |
| * @param argumentClassNames |
| * @return |
| * @since 1.0.0 |
| */ |
| public IMethodProxy getMethodProxy(String methodName, String[] argumentClassNames); |
| |
| /** |
| * Return the method proxy on the receiver with the specified name and one argument |
| * |
| * @param methodName |
| * @param argumentClassName |
| * @return |
| * @since 1.0.0 |
| */ |
| public IMethodProxy getMethodProxy(String methodName, String argumentClassName); |
| |
| /** |
| * Return the method proxy on the receiver with the beanTypes as arguments |
| * |
| * @param methodName |
| * @param argumentTypes |
| * @return |
| * @since 1.0.0 |
| */ |
| public IMethodProxy getMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes); |
| |
| /** |
| * Return an array of public methods for this class. |
| * |
| * @return an array of method proxies or <code>null</code> if an error. |
| * |
| * @since 1.1.0 |
| */ |
| public IMethodProxy[] getMethods(); |
| |
| /** |
| * Return the declared method proxy on the receiver with the specified arguments Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IMethodProxy getDeclaredMethodProxy(String methodName, String[] argumentClassNames); |
| |
| /** |
| * Return the declared method proxy on the receiver with the specified types Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IMethodProxy getDeclaredMethodProxy(String methodName, IBeanTypeProxy[] argumentTypes); |
| |
| /** |
| * Return an array of declared methods for this class. |
| * |
| * @return an array of method proxies or <code>null</code> if an error. |
| * |
| * @since 1.1.0 |
| */ |
| public IMethodProxy[] getDeclaredMethods(); |
| |
| /** |
| * Return the invokable on the receiver with the specified name and no arguments. |
| * <p> |
| * The method proxy is not retrieved. Instead the method will be looked up |
| * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should |
| * be retrieved instead. |
| * <p> |
| * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise |
| * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy. |
| * <p> |
| * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done. |
| * |
| * @param methodName |
| * @return |
| * @since 1.0.0 |
| */ |
| public IInvokable getInvokable(String methodName); |
| |
| /** |
| * Return the method proxy on the receiver with the qualified class names as string arguments |
| * <p> |
| * The method proxy is not retrieved. Instead the method will be looked up |
| * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should |
| * be retrieved instead. |
| * <p> |
| * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise |
| * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy. |
| * <p> |
| * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done. |
| * |
| * @param methodName |
| * @param argumentClassNames |
| * @return |
| * @since 1.0.0 |
| */ |
| public IInvokable getInvokable(String methodName, String[] argumentClassNames); |
| |
| /** |
| * Return the method proxy on the receiver with the specified name and one argument |
| * <p> |
| * The method proxy is not retrieved. Instead the method will be looked up |
| * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should |
| * be retrieved instead. |
| * <p> |
| * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise |
| * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy. |
| * <p> |
| * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done. |
| * |
| * @param methodName |
| * @param argumentClassName |
| * @return |
| * @since 1.0.0 |
| */ |
| public IInvokable getInvokable(String methodName, String argumentClassName); |
| |
| /** |
| * Return the method proxy on the receiver with the beanTypes as arguments |
| * <p> |
| * The method proxy is not retrieved. Instead the method will be looked up |
| * each time on the vm. Because of this these are suitable only for one-shot invokations. If it is to be invoked often, then a method proxy should |
| * be retrieved instead. |
| * <p> |
| * Though typical for one-shot deal the invokable can be used over and over. There is just overhead because the method is looked up each time. So a reasonable compromise |
| * would be if using it infrequently or is used closely together once or twice it is better to use a Invokable instead of a method proxy. |
| * <p> |
| * Note there is no guarantee that the method is available. This won't be known until the actual invoke is done. |
| * |
| * @param methodName |
| * @param argumentTypes |
| * @return |
| * @since 1.0.0 |
| */ |
| public IInvokable getInvokable(String methodName, IBeanTypeProxy[] argumentTypes); |
| |
| /** |
| * Return the constructor proxy on the receiver with no arguments Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IConstructorProxy getNullConstructorProxy(); |
| |
| /** |
| * Answer the type proxy for the superclass Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IBeanTypeProxy getSuperBeanTypeProxy(); |
| |
| /** |
| * Answer the name of the type we are proxying This is the fully qualified name. For arrays it will return the format: [Lclassname; Creation date: |
| * (12/3/99 2:25:07 PM) |
| */ |
| public String getTypeName(); |
| |
| /** |
| * Answer the formal format type name. For normal classes, this just the same as getTypeName(), but for arrays, it is of the format classname[] |
| */ |
| public String getFormalTypeName(); |
| |
| /** |
| * Answer a boolean as to whether we are an array type. |
| */ |
| public boolean isArray(); |
| |
| /** |
| * Answer a boolean as to whether we are a type or an interface Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public boolean isInterface(); |
| |
| /** |
| * Answer a boolean as to whether we are a primitive or not. |
| */ |
| public boolean isPrimitive(); |
| |
| /** |
| * Answer a boolean as to whether we are a kind of the argument We can either be it, inherit from it, or implement it |
| */ |
| public boolean isKindOf(IBeanTypeProxy aBeanProxyType); |
| |
| /** |
| * Return a new instance Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IBeanProxy newInstance() throws ThrowableProxy; |
| |
| /** |
| * Return a new instance of this type using the initialization string to create the proxy. ClassCastException is thrown if the initstring doesn't |
| * result in an object compatible with this type. InstantiationException is thrown when the initialization string cannot be parsed correctly. |
| * Creation date: (12/3/99 2:25:07 PM) |
| */ |
| public IBeanProxy newInstance(String initializationString) throws ThrowableProxy, ClassCastException, InstantiationException; |
| |
| /** |
| * Return the exception message that happened when trying to find this bean type. Class not found is not such an exception. In that case the bean |
| * type will be returned as a null instead. An example of such is an initialization error during loading the class, i.e. it was found but some |
| * static failed to initialize. |
| * |
| * Return null if there is no initialization error. |
| */ |
| public String getInitializationError(); |
| } |