/*******************************************************************************
* Copyright (c) 2001, 2008 Oracle 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:
* Oracle Corporation - initial API and implementation
*******************************************************************************/
package org.eclipse.jst.jsf.core.internal.jem;
import org.eclipse.core.resources.IProject;
import org.eclipse.jdt.core.IField;
import org.eclipse.jdt.core.IJavaProject;
import org.eclipse.jdt.core.IType;
import org.eclipse.jdt.core.JavaCore;
import org.eclipse.jdt.core.JavaModelException;
import org.eclipse.jem.internal.proxy.core.IBeanProxy;
import org.eclipse.jem.internal.proxy.core.IBeanTypeProxy;
import org.eclipse.jem.internal.proxy.core.IFieldProxy;
import org.eclipse.jem.internal.proxy.core.IIntegerBeanProxy;
import org.eclipse.jem.internal.proxy.core.IMethodProxy;
import org.eclipse.jem.internal.proxy.core.IStringBeanProxy;
import org.eclipse.jem.internal.proxy.core.ThrowableProxy;
import org.eclipse.jst.jsf.common.util.TypeUtil;
import org.eclipse.jst.jsf.core.internal.JSFCorePlugin;
/**
* Convenience methods for using bean proxies
*
* @author cbateman
*
*/
public final class BeanProxyUtil
{
/**
* A convenience wrapper for manipulating JEM proxy types
*
*/
public static class BeanProxyWrapper
{
private final static IBeanProxy[] NO_ARGS = new IBeanProxy[0];
private final static IBeanTypeProxy[] NO_ARG_TYPES = new IBeanTypeProxy[0];
private final IBeanTypeProxy _typeProxy;
private final IProject _project;
private IBeanProxy _instance;
/**
* @param project
* @param typeProxy
*/
public BeanProxyWrapper(final IProject project, final IBeanTypeProxy typeProxy)
{
super();
_typeProxy = typeProxy;
_project = project;
}
/**
* Initialize a proxied instance of the type referred to by typeProxy.
*
* @throws ProxyException
*/
public void init() throws ProxyException
{
if (_instance == null)
{
try
{
_instance = _typeProxy.newInstance();
}
catch (final ThrowableProxy e)
{
throw new ProxyException(e);
}
catch (final NoClassDefFoundError ndfe)
{
throw new ProxyException(ndfe);
}
catch (final ExceptionInInitializerError e)
{
throw new ProxyException(e);
}
}
}
/**
* Re-initialize the proxied instance of typeProxy.
*
* @throws ProxyException
*/
public void reinit() throws ProxyException
{
_instance = null;
init();
}
/**
* @return the instance proxy
*/
public IBeanProxy getInstance()
{
return _instance;
}
/**
* <p>
* Call the method called methodName on the proxied instance. If
* args.length is 0 then the zero-argument method is found and called.
* </p>
*
* @param methodName
* @param args
* @param argTypes
* @return the result of calling the method or null if there is no such
* method.
* @throws ProxyException
*/
public IBeanProxy call(final String methodName,
final IBeanProxy[] args, final IBeanTypeProxy[] argTypes)
throws ProxyException
{
try
{
final IMethodProxy method = getMethodProxy(methodName, argTypes);
/*(argTypes.length == 0) ? _typeProxy
.getMethodProxy(methodName) : _typeProxy
.getMethodProxy(methodName, argTypes);*/
if (method != null)
{
method.setAccessible(true);
return method.invoke(_instance, args);
}
}
catch (final ThrowableProxy tp)
{
throw new ProxyException(tp);
}
catch (final NoClassDefFoundError ndfe)
{
throw new ProxyException(ndfe);
}
return null;
}
/**
* Convenience method for call(methodName, new {@link IBeanProxy}[0],
* new {@link IBeanTypeProxy}[0])
*
* @param methodName
* @return the proxied return value
* @throws ProxyException
*/
public IBeanProxy call(final String methodName) throws ProxyException
{
return call(methodName, NO_ARGS, NO_ARG_TYPES);
}
/**
* <p>
* Calls the zero-argument method called 'methodName' on the proxied
* instance and if it results in a String return value, returns it. If
* the method does not return a String value, then null is returned.
* </p>
*
* @param methodName
* @return the string value or null.
* @throws ProxyException
*/
public String callStringMethod(final String methodName)
throws ProxyException
{
final IBeanProxy result = call(methodName);
if (result instanceof IStringBeanProxy)
{
return ((IStringBeanProxy) result).stringValue();
}
return null;
}
/**
* <p>
* Calls the zero-argument method called 'methodName' on the proxied
* instance and if it results in an Integer value, returns it. If the
* method does not return an integer value, then null is returned.
* </p>
*
* @param methodName
* @return the integer value or null.
* @throws ProxyException
*/
public Integer callIntMethod(final String methodName)
throws ProxyException
{
final IBeanProxy result = call(methodName, NO_ARGS, NO_ARG_TYPES);
if (result instanceof IIntegerBeanProxy)
{
return Integer.valueOf(((IIntegerBeanProxy) result).intValue());
}
return null;
}
/**
* Use the typeProxy for the proxied instance to try to acquire the
* field called fieldName of type String. Note that this won't find
* private fields on supertypes.
*
* Equivalent to getStringFieldValue(fieldName, _typeProxy);
*
* @param fieldName
* @return the String value of fieldName on the proxied instance or
* null.
* @throws ProxyException
*/
public String getStringFieldValue(final String fieldName)
throws ProxyException
{
return getStringFieldValue(fieldName, _typeProxy);
}
/**
* Use the provided typeProxy to acquire the field proxy for the field
* proxy called fieldName. Normally, you would use the type proxy of the
* instance bean, however there are cases such as acquiring the value a
* private field on a supertype where you need the type proxy for the
* super type.
*
* @param fieldName
* @param typeProxy
* @return the string value or null.
* @throws ProxyException
*/
public String getStringFieldValue(final String fieldName,
final IBeanTypeProxy typeProxy) throws ProxyException
{
final IBeanProxy value = getFieldValue(fieldName, typeProxy);
if (value instanceof IStringBeanProxy)
{
return ((IStringBeanProxy) value).stringValue();
}
return null;
}
/**
* @param fieldName
* @param typeProxy
* @return the declared field value on the proxied instance called
* fieldName or null.
* @throws ProxyException
*/
public IBeanProxy getFieldValue(final String fieldName,
final IBeanTypeProxy typeProxy) throws ProxyException
{
// avoid having JEM log a warning if we can prove the call to find
// the field will fail
if (!hasField(fieldName))
{
return null;
}
try
{
final IFieldProxy fieldProxy = typeProxy
.getDeclaredFieldProxy(fieldName);
if (fieldProxy != null)
{
fieldProxy.setAccessible(true);
return fieldProxy.get(_instance);
}
}
catch (final ThrowableProxy e)
{
throw new ProxyException(e);
}
catch (final NoClassDefFoundError ndfe)
{
throw new ProxyException(ndfe);
}
return null;
}
/**
* Same as {@link #getFieldValue(String, IBeanTypeProxy)} except it will
* climb the parent hierarchy looking for the first field called
* fieldName.
*
* @param fieldName
* @param typeProxy
* @return the proxied value or null
* @throws ProxyException
*/
public IBeanProxy getFieldValueIncludeParents(final String fieldName,
final IBeanTypeProxy typeProxy) throws ProxyException
{
IBeanTypeProxy curType = typeProxy;
PARENT_LOOP: while (curType != null)
{
final IBeanProxy field = getFieldValue(fieldName, curType);
if (field != null)
{
return field;
}
try
{
IBeanTypeProxy oldType = curType;
curType = curType.getSuperBeanTypeProxy();
// avoid infinite loop: if the parent of curType can't
// be resolved, JEM returns the same type, so curType
// never becomes null
if (oldType == curType)
{
break PARENT_LOOP;
}
}
catch (final NullPointerException npe)
{
// suppress npe caused by getSuperBeanTypeProxy
// not doing a null check on getSuperType()
curType = null;
}
}
// have got to the top of hierarchy and not found the field
return null;
}
/**
* @return the proxied instance
*/
public final IBeanProxy getBeanProxy()
{
return _instance;
}
private IMethodProxy getMethodProxy(final String methodName, final IBeanTypeProxy[] argTypes)
{
IBeanTypeProxy curType = _typeProxy;
PARENT_LOOP: while (curType != null)
{
final IMethodProxy[] declaredMethods = curType.getDeclaredMethods();
if (declaredMethods != null)
{
final IMethodProxy foundMethod = findMethodInList(methodName, argTypes, declaredMethods);
if (foundMethod != null)
{
return foundMethod;
}
}
// avoid infinite loop: if the parent of curType can't
// be resolved, JEM returns the same type, so curType
// never becomes null
IBeanTypeProxy oldType = curType;
curType = _typeProxy.getSuperBeanTypeProxy();
if (oldType == curType)
{
break PARENT_LOOP;
}
}
return null;
}
private IMethodProxy findMethodInList(final String methodName, final IBeanTypeProxy[] argTypes,
final IMethodProxy[] listOfMethods)
{
METHODS_LOOP: for (final IMethodProxy methodProxy : listOfMethods)
{
if (methodName.equals(methodProxy.getName()))
{
final IBeanTypeProxy[] parameterTypes =
methodProxy.getParameterTypes();
if (argTypes.length == parameterTypes.length)
{
for (int i = 0; i < argTypes.length; i++)
{
if (!argTypes[i].getTypeName().equals(parameterTypes[i].getTypeName()))
{
// if we find a parameter type mismatch, then
// skip this method; it's not it
continue METHODS_LOOP;
}
}
// if we get to here, we have a method with right name
// and parameters
return methodProxy;
}
}
}
return null;
}
private boolean hasField(final String fieldName)
{
final IType type = lazilyCalculateType();
if (type != null)
{
final IField field = type.getField(fieldName);
return field.exists();
}
return false;
}
private IType _type;
private boolean _checkedType;
private IType lazilyCalculateType()
{
if (!_checkedType)
{
_checkedType = true;
final String typeName = _typeProxy.getTypeName();
final IJavaProject javaProject = JavaCore.create(_project);
if (typeName != null && typeName.startsWith("L")) //$NON-NLS-1$
{
_type = TypeUtil.resolveType(javaProject, typeName);
}
else
{
try
{
_type = javaProject.findType(typeName);
}
catch (JavaModelException e)
{
JSFCorePlugin.log(e, "While loading type: "+typeName); //$NON-NLS-1$
}
}
}
return _type;
}
// private Map<String, List<IMethod>> _methods;
//
// private Map<String, List<IMethod>> lazilyCalculateMethods(final IType type)
// {
// if (_methods == null)
// {
// _methods = new HashMap<String, List<IMethod>>();
// final JDTBeanIntrospector introspector = new JDTBeanIntrospector(type);
// final IMethod[] methods = introspector.getAllMethods();
//
// for (final IMethod method : methods)
// {
// List<IMethod> byName = _methods.get(method.getElementName());
// if (byName == null)
// {
// byName = new ArrayList<IMethod>();
// _methods.put(method.getElementName(), byName);
// }
//
// try {
// if (method.exists()
// && Flags.isPublic(method.getFlags()))
// {
// byName.add(method);
// }
// } catch (JavaModelException e) {
// JSFCorePlugin.log(e, "While getting flags on method: "+method.getElementName());
// }
// }
// }
// return _methods;
// }
}
/**
* Checked exception the wraps problems thrown by JEM proxying into a single
* exception
*
*/
public static class ProxyException extends Exception
{
private static final long serialVersionUID = -1526057761795574331L;
/**
* @param message
* @param cause
*/
public ProxyException(final String message, final Throwable cause)
{
super(message, cause);
}
/**
* @param cause
*/
public ProxyException(final Throwable cause)
{
super(cause);
}
}
}