plugins/org.eclipse.jem.proxy/proxyCommon/org/eclipse/jem/internal/proxy/common/MethodHelper.java - gerrit/jeetools/webtools.javaee - Git at Google

 /*******************************************************************************
  * 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.common;
 import java.lang.reflect.*;
 import java.text.MessageFormat;
 import java.util.*;

 /**
  * This is a class to do message/constructor work.
  * Specifically to find the most appropriate method.
  */
 public class MethodHelper {

 	/*
 	 * The class that is used to represent Null class type.
 	 *
 	 * @since 1.0.0
 	 */
 	private static class NULL_CLASS {
 	}

 	public static final Class NULL_TYPE = NULL_CLASS.class;

 	static final ArrayList sPrimitivesOrder;
 	static final int sCharPos;

 	static {
 		sPrimitivesOrder = new ArrayList(6);
 		sPrimitivesOrder.add(Byte.TYPE);
 		sPrimitivesOrder.add(Short.TYPE);
 		sPrimitivesOrder.add(Integer.TYPE);
 		sPrimitivesOrder.add(Long.TYPE);
 		sPrimitivesOrder.add(Float.TYPE);
 		sPrimitivesOrder.add(Double.TYPE);

 		// char can be treated like a short for purposes of ordering.
 		sCharPos = sPrimitivesOrder.indexOf(Short.TYPE);
 	}

 	/**
 	 * Return whether the type2 can be assigned to type1 in
 	 * method argument conversion.
 	 */
 	public static boolean isAssignableFrom(Class type1, Class type2) {
 		if (type1 == type2)
 			return true;	// They're the same, so assignable.
 		if (type1.isPrimitive()) {
 			if (type2.isPrimitive()) {
 				if (type1 == Boolean.TYPE || type2 == Boolean.TYPE)
 					return false;	// Since not equal and one is boolean and the other isn't, not assignable
 				int type1Pos = (type1 != Character.TYPE) ? sPrimitivesOrder.indexOf(type1) : sCharPos;
 				int type2Pos = (type2 != Character.TYPE) ? sPrimitivesOrder.indexOf(type2) : sCharPos;
 				return type1Pos > type2Pos;	// It can be widened if type1 is higher in the order
 			}
 			return false;	// primitive to non-primitive, not assignable.
 		} else
 			if (type2 == NULL_TYPE)
 				return true;	// NULL_TYPE represents null for us, and null can be assigned to any object
 			else
 				return type1.isAssignableFrom(type2);	// Can type2 be assigned to type1
 	}


 	/**
 	 * Every entry in Array2 can be assigned to the corresponding entry in Array1.
 	 */
 	public static boolean isAssignableFrom(Class[] types1, Class[] types2) {
 		if (types1.length != types2.length)
 			return false;	// Not the same size, so not compatible.
 		for (int i=0; i<types1.length; i++) {
 			if (!isAssignableFrom(types1[i], types2[i]))
 				return false;
 		}
 		return true;	// All are assignable
 	}

 	/**
 	 * Return the index of the most compatible method/constructor from the lists passed in.
 	 * MethodsList: List of methods (if null then this is for constructors)
 	 * ParmsList: List of parms for each method (each entry will be Class[]).
 	 */
 	private static int findMostCompatible(List methods, List parms, String ambiguousName) throws AmbiguousMethodException {
 		// The algorithm used is from the Java Language Specification 15.12.2.2
 		// Find the maximally specific ones
 		// This is defined as the one that is more specific then all of the rest.
 		// If there are duplicates parms that are maximally specific, then it doesn't matter which choosen
 		// because when invoked the JVM will make sure the right thing is done.
 		//
 		Class[][] parmsCopy = (Class[][]) parms.toArray(new Class[parms.size()][]);
 		int size = parmsCopy.length;
 		// For each entry see if it is maximally specific, i.e. it is more specific then all of the others.
 nextMethod:	for (int i=0; i<size; i++) {
 			// For ctors we don't need to test the declaring class because it will always be the same class.
 			Class dclClassi = methods != null ? ((Method) methods.get(i)).getDeclaringClass() : null;
 			Class[] parmsi = parmsCopy[i];
 			for (int j=0; j<size; j++) {
 				if (i == j)
 					continue;
 				// Methodi is more specific if
 				//   a) Methodi declaring class is assignable to Methodj declaring class
 				//   b) Methodi parms are assignable to Methodj parms
 				//
 				// First see if Methodi is more specific, if it is
 				// then throw out Methodj and continue
 				// If Methodi is not compatible to Methodj, go to the next method for i. Methodi is not the most specific
 				// Something else is either more specific or none are ma
 				if (dclClassi != null) {
 					// Step a
 					if (!isAssignableFrom(((Method) methods.get(j)).getDeclaringClass(), dclClassi))
 						continue nextMethod;	// Methodi is not more specific than Methodj, so try next i.
 				}

 				// Step b
 				Class[] parmsj = parmsCopy[j];
 				if (!isAssignableFrom(parmsj, parmsi)) {
 					// Methodi is not more specific than Methodj, so go to next i.
 					continue nextMethod;
 				}
 			}
 			return i;	// Methodi is more specific than all of the other ones.
 		}

 		throw new AmbiguousMethodException(ambiguousName);	// There was not one more specific than all of the others.
 	}

 	/**
 	 * Find the most compatible method for the given arguments.
 	 */
 	public static Method findCompatibleMethod(Class receiver, String methodName, Class[] arguments) throws NoSuchMethodException, AmbiguousMethodException {
 		try {
 			return receiver.getMethod(methodName, arguments);	// Found exact match in public
 		} catch (NoSuchMethodException exc) {
 			if (arguments != null) {
 				// Need to find most compatible one. We will take protected into consideration (i.e. inheritance).
 				ArrayList parmsList = new ArrayList(); // The parm list from each compatible method.
 				ArrayList mthdsList = new ArrayList(); // The list of compatible methods, same order as the parms above.
 				Class cls = receiver;
 				while (cls != null) {
 					Method mthds[] = cls.getDeclaredMethods();
 					for (int i = 0; i < mthds.length; i++) {
 						Method mthd = mthds[i];
 						if (!mthd.getName().equals(methodName))
 							continue; // Not compatible, not same name
 						int modifiers = mthd.getModifiers();
 						if (!(Modifier.isPublic(modifiers) || Modifier.isProtected(modifiers)))
 							continue;	 // Will not call private or package-protected because we don't know the context.
 						Class[] parms = mthd.getParameterTypes();
 						// If exact match we found a non-public exact match, which is good.
 						if (Arrays.equals(arguments, parms))
 							return makeMethodAccessable(mthd);
 						if (!isAssignableFrom(parms, arguments))
 							continue; // Not compatible, parms
 						// It is compatible with the requested method - now see if we already have an exact match from a subclass. Don't want to add it twice.
 						// We are assuming the actual number of compatible methods is small, so this O(n-squared) search is efficient enough.
 						int size = parmsList.size();
 						for (int j = 0; j < size; j++) {
 							if (Arrays.equals(parms, (Object[]) parmsList.get(j)))
 								continue;
 						}
 						parmsList.add(parms);
 						mthdsList.add(mthd);
 					}
 					cls = cls.getSuperclass();
 				}
 				// Now have list of compatible methods.
 				if (parmsList.size() == 0)
 					throw throwFixedNoSuchMethod(exc, receiver, methodName, arguments); // None found, so rethrow the exception
 				if (parmsList.size() == 1)
 					return makeMethodAccessable((Method) mthdsList.get(0)); // Only one, so return it

 				// Now find the most compatible method
 				int mostCompatible = findMostCompatible(mthdsList, parmsList, methodName);
 				return makeMethodAccessable((Method) mthdsList.get(mostCompatible));
 			} else
 				throw throwFixedNoSuchMethod(exc, receiver, methodName, arguments); // None found, so rethrow the exception
 		}
 	}

 	private static Method makeMethodAccessable(Method m) {
 		m.setAccessible(true);	// We allow all access, let ide and compiler handle security.
 		return m;
 	}

 	/*
 	 * NoSuchMEthodExeception doesn't include the signature. Since these are dynamic searches, the exception itself is useless without
 	 * the signature. So we add it.
 	 */
 	private static NoSuchMethodException throwFixedNoSuchMethod(NoSuchMethodException e, Class declareClass, String methodName, Class[] argClasses) {

 		// The default trace doesn't show what method was being searched for, so recreate with that.
 		StringBuffer s = new StringBuffer();
 		s.append(declareClass.getName());
 		s.append('.');
 		s.append(methodName);
 		s.append('(');
 		if (argClasses != null) {
 			for (int i = 0; i < argClasses.length; i++) {
 				if (i > 0)
 					s.append(',');
 				s.append(argClasses[i].getName());
 			}
 		}
 		s.append(')');
 		NoSuchMethodException ne = new NoSuchMethodException(s.toString());
 		ne.setStackTrace(e.getStackTrace());
 		return ne;
 	}


 	/**
 	 * Find the most compatible constructor for the class with the given arguments.
 	 * @param receiver class to get the constructor for
 	 * @param arguments array of argument types
 	 * @return the constructor
 	 * @throws NoSuchMethodException no compatible constructor can be found
 	 * @throws AmbiguousMethodException there is more than one compatible constructor
 	 * @throws IllegalAccessException it can't be accessed. Such as it is a non-static inner class.
 	 *
 	 * @since 1.2.0
 	 */
 	public static Constructor findCompatibleConstructor(Class receiver, Class[] arguments) throws NoSuchMethodException, AmbiguousMethodException, IllegalAccessException {
 		if (receiver.getDeclaringClass() != null && !Modifier.isStatic(receiver.getModifiers()))
 			throw new IllegalAccessException(MessageFormat.format(Messages.getString("MethodHelper.NONSTATICINNERCLASS_WARNING"), new Object[] {receiver.getName()})); //$NON-NLS-1$
 		try {
 			java.lang.reflect.Constructor ctor = receiver.getDeclaredConstructor(arguments);
 			ctor.setAccessible(true);	// We allow all access, let ide and compiler handle security.
 			return ctor;	// Found exact match
 		} catch (NoSuchMethodException exc) {
 			if (arguments != null) {
 				// Need to find most compatible one.
 				java.lang.reflect.Constructor ctors[] = receiver.getDeclaredConstructors();
 				ArrayList parmsList = new ArrayList(ctors.length); // The parm list from each compatible method.
 				ArrayList ctorsList = new ArrayList(ctors.length); // The list of compatible methods, same order as the parms above.
 				for (int i = 0; i < ctors.length; i++) {
 					java.lang.reflect.Constructor ctor = ctors[i];
 					Class[] parms = ctor.getParameterTypes();
 					if (!isAssignableFrom(parms, arguments))
 						continue; // Not compatible, parms
 					// It is compatible with the requested method
 					parmsList.add(parms);
 					ctorsList.add(ctor);
 				}

 				// Now have list of compatible methods.
 				if (parmsList.size() == 0)
 					throw exc; // None found, so rethrow the exception
 				if (parmsList.size() == 1) {
 					java.lang.reflect.Constructor ctor = (java.lang.reflect.Constructor) ctorsList.get(0); // Only one, so return it
 					ctor.setAccessible(true); // We allow all access, let ide and compilor handle security.
 					return ctor;
 				}

 				// Now find the most compatible ctor
 				int mostCompatible = findMostCompatible(null, parmsList, receiver.getName());
 				java.lang.reflect.Constructor ctor = (java.lang.reflect.Constructor) ctorsList.get(mostCompatible);
 				ctor.setAccessible(true); // We allow all access, let ide and compilor handle security.
 				return ctor;
 			} else
 				throw exc; // None found, so rethrow the exception
 		}
 	}


 }
	/*******************************************************************************
	* 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.common;
	import java.lang.reflect.*;
	import java.text.MessageFormat;
	import java.util.*;

	/**
	* This is a class to do message/constructor work.
	* Specifically to find the most appropriate method.
	*/
	public class MethodHelper {

	/*
	* The class that is used to represent Null class type.
	*
	* @since 1.0.0
	*/
	private static class NULL_CLASS {
	}

	public static final Class NULL_TYPE = NULL_CLASS.class;

	static final ArrayList sPrimitivesOrder;
	static final int sCharPos;

	static {
	sPrimitivesOrder = new ArrayList(6);
	sPrimitivesOrder.add(Byte.TYPE);
	sPrimitivesOrder.add(Short.TYPE);
	sPrimitivesOrder.add(Integer.TYPE);
	sPrimitivesOrder.add(Long.TYPE);
	sPrimitivesOrder.add(Float.TYPE);
	sPrimitivesOrder.add(Double.TYPE);

	// char can be treated like a short for purposes of ordering.
	sCharPos = sPrimitivesOrder.indexOf(Short.TYPE);
	}

	/**
	* Return whether the type2 can be assigned to type1 in
	* method argument conversion.
	*/
	public static boolean isAssignableFrom(Class type1, Class type2) {
	if (type1 == type2)
	return true; // They're the same, so assignable.
	if (type1.isPrimitive()) {
	if (type2.isPrimitive()) {
	if (type1 == Boolean.TYPE \|\| type2 == Boolean.TYPE)
	return false; // Since not equal and one is boolean and the other isn't, not assignable
	int type1Pos = (type1 != Character.TYPE) ? sPrimitivesOrder.indexOf(type1) : sCharPos;
	int type2Pos = (type2 != Character.TYPE) ? sPrimitivesOrder.indexOf(type2) : sCharPos;
	return type1Pos > type2Pos; // It can be widened if type1 is higher in the order
	}
	return false; // primitive to non-primitive, not assignable.
	} else
	if (type2 == NULL_TYPE)
	return true; // NULL_TYPE represents null for us, and null can be assigned to any object
	else
	return type1.isAssignableFrom(type2); // Can type2 be assigned to type1
	}


	/**
	* Every entry in Array2 can be assigned to the corresponding entry in Array1.
	*/
	public static boolean isAssignableFrom(Class[] types1, Class[] types2) {
	if (types1.length != types2.length)
	return false; // Not the same size, so not compatible.
	for (int i=0; i<types1.length; i++) {
	if (!isAssignableFrom(types1[i], types2[i]))
	return false;
	}
	return true; // All are assignable
	}

	/**
	* Return the index of the most compatible method/constructor from the lists passed in.
	* MethodsList: List of methods (if null then this is for constructors)
	* ParmsList: List of parms for each method (each entry will be Class[]).
	*/
	private static int findMostCompatible(List methods, List parms, String ambiguousName) throws AmbiguousMethodException {
	// The algorithm used is from the Java Language Specification 15.12.2.2
	// Find the maximally specific ones
	// This is defined as the one that is more specific then all of the rest.
	// If there are duplicates parms that are maximally specific, then it doesn't matter which choosen
	// because when invoked the JVM will make sure the right thing is done.
	//
	Class[][] parmsCopy = (Class[][]) parms.toArray(new Class[parms.size()][]);
	int size = parmsCopy.length;
	// For each entry see if it is maximally specific, i.e. it is more specific then all of the others.
	nextMethod: for (int i=0; i<size; i++) {
	// For ctors we don't need to test the declaring class because it will always be the same class.
	Class dclClassi = methods != null ? ((Method) methods.get(i)).getDeclaringClass() : null;
	Class[] parmsi = parmsCopy[i];
	for (int j=0; j<size; j++) {
	if (i == j)
	continue;
	// Methodi is more specific if
	// a) Methodi declaring class is assignable to Methodj declaring class
	// b) Methodi parms are assignable to Methodj parms
	//
	// First see if Methodi is more specific, if it is
	// then throw out Methodj and continue
	// If Methodi is not compatible to Methodj, go to the next method for i. Methodi is not the most specific
	// Something else is either more specific or none are ma
	if (dclClassi != null) {
	// Step a
	if (!isAssignableFrom(((Method) methods.get(j)).getDeclaringClass(), dclClassi))
	continue nextMethod; // Methodi is not more specific than Methodj, so try next i.
	}

	// Step b
	Class[] parmsj = parmsCopy[j];
	if (!isAssignableFrom(parmsj, parmsi)) {
	// Methodi is not more specific than Methodj, so go to next i.
	continue nextMethod;
	}
	}
	return i; // Methodi is more specific than all of the other ones.
	}

	throw new AmbiguousMethodException(ambiguousName); // There was not one more specific than all of the others.
	}

	/**
	* Find the most compatible method for the given arguments.
	*/
	public static Method findCompatibleMethod(Class receiver, String methodName, Class[] arguments) throws NoSuchMethodException, AmbiguousMethodException {
	try {
	return receiver.getMethod(methodName, arguments); // Found exact match in public
	} catch (NoSuchMethodException exc) {
	if (arguments != null) {
	// Need to find most compatible one. We will take protected into consideration (i.e. inheritance).
	ArrayList parmsList = new ArrayList(); // The parm list from each compatible method.
	ArrayList mthdsList = new ArrayList(); // The list of compatible methods, same order as the parms above.
	Class cls = receiver;
	while (cls != null) {
	Method mthds[] = cls.getDeclaredMethods();
	for (int i = 0; i < mthds.length; i++) {
	Method mthd = mthds[i];
	if (!mthd.getName().equals(methodName))
	continue; // Not compatible, not same name
	int modifiers = mthd.getModifiers();
	if (!(Modifier.isPublic(modifiers) \|\| Modifier.isProtected(modifiers)))
	continue; // Will not call private or package-protected because we don't know the context.
	Class[] parms = mthd.getParameterTypes();
	// If exact match we found a non-public exact match, which is good.
	if (Arrays.equals(arguments, parms))
	return makeMethodAccessable(mthd);
	if (!isAssignableFrom(parms, arguments))
	continue; // Not compatible, parms
	// It is compatible with the requested method - now see if we already have an exact match from a subclass. Don't want to add it twice.
	// We are assuming the actual number of compatible methods is small, so this O(n-squared) search is efficient enough.
	int size = parmsList.size();
	for (int j = 0; j < size; j++) {
	if (Arrays.equals(parms, (Object[]) parmsList.get(j)))
	continue;
	}
	parmsList.add(parms);
	mthdsList.add(mthd);
	}
	cls = cls.getSuperclass();
	}
	// Now have list of compatible methods.
	if (parmsList.size() == 0)
	throw throwFixedNoSuchMethod(exc, receiver, methodName, arguments); // None found, so rethrow the exception
	if (parmsList.size() == 1)
	return makeMethodAccessable((Method) mthdsList.get(0)); // Only one, so return it

	// Now find the most compatible method
	int mostCompatible = findMostCompatible(mthdsList, parmsList, methodName);
	return makeMethodAccessable((Method) mthdsList.get(mostCompatible));
	} else
	throw throwFixedNoSuchMethod(exc, receiver, methodName, arguments); // None found, so rethrow the exception
	}
	}

	private static Method makeMethodAccessable(Method m) {
	m.setAccessible(true); // We allow all access, let ide and compiler handle security.
	return m;
	}

	/*
	* NoSuchMEthodExeception doesn't include the signature. Since these are dynamic searches, the exception itself is useless without
	* the signature. So we add it.
	*/
	private static NoSuchMethodException throwFixedNoSuchMethod(NoSuchMethodException e, Class declareClass, String methodName, Class[] argClasses) {

	// The default trace doesn't show what method was being searched for, so recreate with that.
	StringBuffer s = new StringBuffer();
	s.append(declareClass.getName());
	s.append('.');
	s.append(methodName);
	s.append('(');
	if (argClasses != null) {
	for (int i = 0; i < argClasses.length; i++) {
	if (i > 0)
	s.append(',');
	s.append(argClasses[i].getName());
	}
	}
	s.append(')');
	NoSuchMethodException ne = new NoSuchMethodException(s.toString());
	ne.setStackTrace(e.getStackTrace());
	return ne;
	}


	/**
	* Find the most compatible constructor for the class with the given arguments.
	* @param receiver class to get the constructor for
	* @param arguments array of argument types
	* @return the constructor
	* @throws NoSuchMethodException no compatible constructor can be found
	* @throws AmbiguousMethodException there is more than one compatible constructor
	* @throws IllegalAccessException it can't be accessed. Such as it is a non-static inner class.
	*
	* @since 1.2.0
	*/
	public static Constructor findCompatibleConstructor(Class receiver, Class[] arguments) throws NoSuchMethodException, AmbiguousMethodException, IllegalAccessException {
	if (receiver.getDeclaringClass() != null && !Modifier.isStatic(receiver.getModifiers()))
	throw new IllegalAccessException(MessageFormat.format(Messages.getString("MethodHelper.NONSTATICINNERCLASS_WARNING"), new Object[] {receiver.getName()})); //$NON-NLS-1$
	try {
	java.lang.reflect.Constructor ctor = receiver.getDeclaredConstructor(arguments);
	ctor.setAccessible(true); // We allow all access, let ide and compiler handle security.
	return ctor; // Found exact match
	} catch (NoSuchMethodException exc) {
	if (arguments != null) {
	// Need to find most compatible one.
	java.lang.reflect.Constructor ctors[] = receiver.getDeclaredConstructors();
	ArrayList parmsList = new ArrayList(ctors.length); // The parm list from each compatible method.
	ArrayList ctorsList = new ArrayList(ctors.length); // The list of compatible methods, same order as the parms above.
	for (int i = 0; i < ctors.length; i++) {
	java.lang.reflect.Constructor ctor = ctors[i];
	Class[] parms = ctor.getParameterTypes();
	if (!isAssignableFrom(parms, arguments))
	continue; // Not compatible, parms
	// It is compatible with the requested method
	parmsList.add(parms);
	ctorsList.add(ctor);
	}

	// Now have list of compatible methods.
	if (parmsList.size() == 0)
	throw exc; // None found, so rethrow the exception
	if (parmsList.size() == 1) {
	java.lang.reflect.Constructor ctor = (java.lang.reflect.Constructor) ctorsList.get(0); // Only one, so return it
	ctor.setAccessible(true); // We allow all access, let ide and compilor handle security.
	return ctor;
	}

	// Now find the most compatible ctor
	int mostCompatible = findMostCompatible(null, parmsList, receiver.getName());
	java.lang.reflect.Constructor ctor = (java.lang.reflect.Constructor) ctorsList.get(mostCompatible);
	ctor.setAccessible(true); // We allow all access, let ide and compilor handle security.
	return ctor;
	} else
	throw exc; // None found, so rethrow the exception
	}
	}


	}