From b92a2b5b0c9062a9110db350798320c812763aca Mon Sep 17 00:00:00 2001 From: Matthew Jason Benson Date: Tue, 2 Feb 2010 20:39:36 +0000 Subject: [PATCH] remove pre Java 5 workaround git-svn-id: https://svn.apache.org/repos/asf/commons/proper/lang/trunk@905786 13f79535-47bb-0310-9956-ffa450edef68 --- .../commons/lang3/reflect/MemberUtils.java | 91 ++++++------------- 1 file changed, 29 insertions(+), 62 deletions(-) diff --git a/src/main/java/org/apache/commons/lang3/reflect/MemberUtils.java b/src/main/java/org/apache/commons/lang3/reflect/MemberUtils.java index efcebbb06..bc9d3c149 100644 --- a/src/main/java/org/apache/commons/lang3/reflect/MemberUtils.java +++ b/src/main/java/org/apache/commons/lang3/reflect/MemberUtils.java @@ -18,16 +18,14 @@ package org.apache.commons.lang3.reflect; import java.lang.reflect.AccessibleObject; import java.lang.reflect.Member; -import java.lang.reflect.Method; import java.lang.reflect.Modifier; -import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.ClassUtils; -import org.apache.commons.lang3.SystemUtils; /** * Contains common code for working with Methods/Constructors, extracted and - * refactored from MethodUtils when it was imported from Commons BeanUtils. + * refactored from MethodUtils when it was imported from Commons + * BeanUtils. * * @author Apache Software Foundation * @author Steve Cohen @@ -40,35 +38,20 @@ abstract class MemberUtils { private static final int ACCESS_TEST = Modifier.PUBLIC | Modifier.PROTECTED | Modifier.PRIVATE; - private static final Method IS_SYNTHETIC; - static { - Method isSynthetic = null; - if (SystemUtils.isJavaVersionAtLeast(1.5f)) { - // cannot call synthetic methods: - try { - isSynthetic = Member.class.getMethod("isSynthetic", - ArrayUtils.EMPTY_CLASS_ARRAY); - } catch (Exception e) { - } - } - IS_SYNTHETIC = isSynthetic; - } - /** Array of primitive number types ordered by "promotability" */ - private static final Class[] ORDERED_PRIMITIVE_TYPES = { Byte.TYPE, - Short.TYPE, Character.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, - Double.TYPE }; + private static final Class[] ORDERED_PRIMITIVE_TYPES = { Byte.TYPE, Short.TYPE, + Character.TYPE, Integer.TYPE, Long.TYPE, Float.TYPE, Double.TYPE }; /** * XXX Default access superclass workaround * - * When a public class has a default access superclass with public - * members, these members are accessible. Calling them from - * compiled code works fine. Unfortunately, on some JVMs, using reflection to invoke these - * members seems to (wrongly) to prevent access even when the - * modifer is public. Calling setAccessible(true) solves the problem - * but will only work from sufficiently privileged code. Better - * workarounds would be gratefully accepted. + * When a public class has a default access superclass with public members, + * these members are accessible. Calling them from compiled code works fine. + * Unfortunately, on some JVMs, using reflection to invoke these members + * seems to (wrongly) to prevent access even when the modifer is public. + * Calling setAccessible(true) solves the problem but will only work from + * sufficiently privileged code. Better workarounds would be gratefully + * accepted. * @param o the AccessibleObject to set as accessible */ static void setAccessibleWorkaround(AccessibleObject o) { @@ -76,7 +59,8 @@ abstract class MemberUtils { return; } Member m = (Member) o; - if (Modifier.isPublic(m.getModifiers()) && isPackageAccess(m.getDeclaringClass().getModifiers())) { + if (Modifier.isPublic(m.getModifiers()) + && isPackageAccess(m.getDeclaringClass().getModifiers())) { try { o.setAccessible(true); } catch (SecurityException e) { @@ -100,33 +84,19 @@ abstract class MemberUtils { * @return true if m is accessible */ static boolean isAccessible(Member m) { - return m != null && Modifier.isPublic(m.getModifiers()) - && !isSynthetic(m); - } - - /** - * Try to learn whether a given member, on JDK >= 1.5, is synthetic. - * @param m Member to check - * @return true if m was introduced by the compiler. - */ - static boolean isSynthetic(Member m) { - if (IS_SYNTHETIC != null) { - try { - return ((Boolean) IS_SYNTHETIC.invoke(m, (Object[]) null)).booleanValue(); - } catch (Exception e) { - } - } - return false; + return m != null && Modifier.isPublic(m.getModifiers()) && !m.isSynthetic(); } /** * Compare the relative fitness of two sets of parameter types in terms of * matching a third set of runtime parameter types, such that a list ordered - * by the results of the comparison would return the best match first (least). + * by the results of the comparison would return the best match first + * (least). * * @param left the "left" parameter set * @param right the "right" parameter set - * @param actual the runtime parameter types to match against left/right + * @param actual the runtime parameter types to match against + * left/right * @return int consistent with compare semantics */ static int compareParameterTypes(Class[] left, Class[] right, Class[] actual) { @@ -136,14 +106,13 @@ abstract class MemberUtils { } /** - * Returns the sum of the object transformation cost for each class in the source - * argument list. + * Returns the sum of the object transformation cost for each class in the + * source argument list. * @param srcArgs The source arguments * @param destArgs The destination arguments * @return The total transformation cost */ - private static float getTotalTransformationCost(Class[] srcArgs, - Class[] destArgs) { + private static float getTotalTransformationCost(Class[] srcArgs, Class[] destArgs) { float totalCost = 0.0f; for (int i = 0; i < srcArgs.length; i++) { Class srcClass, destClass; @@ -155,22 +124,20 @@ abstract class MemberUtils { } /** - * Gets the number of steps required needed to turn the source class into the - * destination class. This represents the number of steps in the object hierarchy - * graph. + * Gets the number of steps required needed to turn the source class into + * the destination class. This represents the number of steps in the object + * hierarchy graph. * @param srcClass The source class * @param destClass The destination class * @return The cost of transforming an object */ - private static float getObjectTransformationCost(Class srcClass, - Class destClass) { + private static float getObjectTransformationCost(Class srcClass, Class destClass) { if (destClass.isPrimitive()) { return getPrimitivePromotionCost(srcClass, destClass); } float cost = 0.0f; while (destClass != null && !destClass.equals(srcClass)) { - if (destClass.isInterface() - && ClassUtils.isAssignable(srcClass, destClass)) { + if (destClass.isInterface() && ClassUtils.isAssignable(srcClass, destClass)) { // slight penalty for interface match. // we still want an exact match to override an interface match, // but @@ -193,13 +160,13 @@ abstract class MemberUtils { } /** - * Get the number of steps required to promote a primitive number to another type. + * Get the number of steps required to promote a primitive number to another + * type. * @param srcClass the (primitive) source class * @param destClass the (primitive) destination class * @return The cost of promoting the primitive */ - private static float getPrimitivePromotionCost(final Class srcClass, - final Class destClass) { + private static float getPrimitivePromotionCost(final Class srcClass, final Class destClass) { float cost = 0.0f; Class cls = srcClass; if (!cls.isPrimitive()) {