commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From mben...@apache.org
Subject svn commit: r983709 - /commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
Date Mon, 09 Aug 2010 16:20:55 GMT
Author: mbenson
Date: Mon Aug  9 16:20:54 2010
New Revision: 983709

URL: http://svn.apache.org/viewvc?rev=983709&view=rev
Log:
move/comment SuppressWarnings(unchecked)/refactor surrounding code

Modified:
    commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java

Modified: commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java?rev=983709&r1=983708&r2=983709&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
(original)
+++ commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
Mon Aug  9 16:20:54 2010
@@ -24,20 +24,22 @@ import org.apache.commons.lang3.ArrayUti
 import org.apache.commons.lang3.ClassUtils;
 
 /**
- * <p> Utility reflection methods focussed on constructors, modelled after {@link MethodUtils}.
</p>
- *
- * <h3>Known Limitations</h3>
- * <h4>Accessing Public Constructors In A Default Access Superclass</h4>
- * <p>There is an issue when invoking public constructors contained in a default access
superclass.
- * Reflection locates these constructors fine and correctly assigns them as public.
- * However, an <code>IllegalAccessException</code> is thrown if the constructors
is invoked.</p>
- *
- * <p><code>ConstructorUtils</code> contains a workaround for this situation.
- * It will attempt to call <code>setAccessible</code> on this constructor.
- * If this call succeeds, then the method can be invoked as normal.
- * This call will only succeed when the application has sufficient security privilages.
- * If this call fails then a warning will be logged and the method may fail.</p>
- *
+ * <p> Utility reflection methods focussed on constructors, modelled after
+ * {@link MethodUtils}. </p>
+ * 
+ * <h3>Known Limitations</h3> <h4>Accessing Public Constructors In A Default
+ * Access Superclass</h4> <p>There is an issue when invoking public constructors
+ * contained in a default access superclass. Reflection locates these
+ * constructors fine and correctly assigns them as public. However, an
+ * <code>IllegalAccessException</code> is thrown if the constructors is
+ * invoked.</p>
+ * 
+ * <p><code>ConstructorUtils</code> contains a workaround for this situation.
It
+ * will attempt to call <code>setAccessible</code> on this constructor. If this
+ * call succeeds, then the method can be invoked as normal. This call will only
+ * succeed when the application has sufficient security privilages. If this call
+ * fails then a warning will be logged and the method may fail.</p>
+ * 
  * @author Apache Software Foundation
  * @author Craig R. McClanahan
  * @author Ralph Schaer
@@ -53,10 +55,10 @@ import org.apache.commons.lang3.ClassUti
 public class ConstructorUtils {
 
     /**
-     * <p>ConstructorUtils instances should NOT be constructed in standard programming.
-     * Instead, the class should be used as
+     * <p>ConstructorUtils instances should NOT be constructed in standard
+     * programming. Instead, the class should be used as
      * <code>ConstructorUtils.invokeConstructor(cls, args)</code>.</p>
-     *
+     * 
      * <p>This constructor is public to permit tools that require a JavaBean
      * instance to operate.</p>
      */
@@ -65,26 +67,31 @@ public class ConstructorUtils {
     }
 
     /**
-     * <p>Returns new instance of <code>klazz</code> created using the
actual arguments <code>args</code>.
-     * The formal parameter types are inferred from the actual values of <code>args</code>.
-     * See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
-     *
+     * <p>Returns new instance of <code>klazz</code> created using the
actual
+     * arguments <code>args</code>. The formal parameter types are inferred from
+     * the actual values of <code>args</code>. See
+     * {@link #invokeExactConstructor(Class, Object[], Class[])} for more
+     * details.</p>
+     * 
      * <p>The signatures should be assignment compatible.</p>
-     *
+     * 
      * @param cls the class to be constructed.
      * @param args actual argument array
      * @return new instance of <code>klazz</code>
-     *
+     * 
      * @throws NoSuchMethodException If the constructor cannot be found
-     * @throws IllegalAccessException If an error occurs accessing the constructor
-     * @throws InvocationTargetException If an error occurs invoking the constructor
+     * @throws IllegalAccessException If an error occurs accessing the
+     * constructor
+     * @throws InvocationTargetException If an error occurs invoking the
+     * constructor
      * @throws InstantiationException If an error occurs instantiating the class
-     *
-     * @see #invokeConstructor(java.lang.Class, java.lang.Object[], java.lang.Class[])
+     * 
+     * @see #invokeConstructor(java.lang.Class, java.lang.Object[],
+     * java.lang.Class[])
      */
     public static <T> T invokeConstructor(Class<T> cls, Object... args)
-            throws NoSuchMethodException, IllegalAccessException,
-            InvocationTargetException, InstantiationException {
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
+            InstantiationException {
         if (null == args) {
             args = ArrayUtils.EMPTY_OBJECT_ARRAY;
         }
@@ -97,24 +104,24 @@ public class ConstructorUtils {
 
     /**
      * <p>Returns new instance of <code>klazz</code> created using constructor
-     * with signature <code>parameterTypes</code> and actual arguments <code>args</code>.</p>
-     *
+     * with signature <code>parameterTypes</code> and actual arguments
+     * <code>args</code>.</p>
+     * 
      * <p>The signatures should be assignment compatible.</p>
-     *
+     * 
      * @param cls the class to be constructed.
      * @param args actual argument array
      * @param parameterTypes parameter types array
      * @return new instance of <code>klazz</code>
-     *
+     * 
      * @throws NoSuchMethodException if matching constructor cannot be found
      * @throws IllegalAccessException thrown on the constructor's invocation
      * @throws InvocationTargetException thrown on the constructor's invocation
      * @throws InstantiationException thrown on the constructor's invocation
      * @see Constructor#newInstance
      */
-    public static <T> T invokeConstructor(Class<T> cls, Object[] args,
-            Class<?>[] parameterTypes) throws NoSuchMethodException,
-            IllegalAccessException, InvocationTargetException,
+    public static <T> T invokeConstructor(Class<T> cls, Object[] args, Class<?>[]
parameterTypes)
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
             InstantiationException {
         if (parameterTypes == null) {
             parameterTypes = ArrayUtils.EMPTY_CLASS_ARRAY;
@@ -124,34 +131,38 @@ public class ConstructorUtils {
         }
         Constructor<T> ctor = getMatchingAccessibleConstructor(cls, parameterTypes);
         if (null == ctor) {
-            throw new NoSuchMethodException(
-                    "No such accessible constructor on object: "
-                            + cls.getName());
+            throw new NoSuchMethodException("No such accessible constructor on object: "
+                    + cls.getName());
         }
         return ctor.newInstance(args);
     }
 
     /**
-     * <p>Returns new instance of <code>klazz</code> created using the
actual arguments <code>args</code>.
-     * The formal parameter types are inferred from the actual values of <code>args</code>.
-     * See {@link #invokeExactConstructor(Class, Object[], Class[])} for more details.</p>
-     *
+     * <p>Returns new instance of <code>klazz</code> created using the
actual
+     * arguments <code>args</code>. The formal parameter types are inferred from
+     * the actual values of <code>args</code>. See
+     * {@link #invokeExactConstructor(Class, Object[], Class[])} for more
+     * details.</p>
+     * 
      * <p>The signatures should match exactly.</p>
-     *
+     * 
      * @param cls the class to be constructed.
      * @param args actual argument array
      * @return new instance of <code>klazz</code>
-     *
+     * 
      * @throws NoSuchMethodException If the constructor cannot be found
-     * @throws IllegalAccessException If an error occurs accessing the constructor
-     * @throws InvocationTargetException If an error occurs invoking the constructor
+     * @throws IllegalAccessException If an error occurs accessing the
+     * constructor
+     * @throws InvocationTargetException If an error occurs invoking the
+     * constructor
      * @throws InstantiationException If an error occurs instantiating the class
-     *
-     * @see #invokeExactConstructor(java.lang.Class, java.lang.Object[], java.lang.Class[])
+     * 
+     * @see #invokeExactConstructor(java.lang.Class, java.lang.Object[],
+     * java.lang.Class[])
      */
     public static <T> T invokeExactConstructor(Class<T> cls, Object... args)
-            throws NoSuchMethodException, IllegalAccessException,
-            InvocationTargetException, InstantiationException {
+            throws NoSuchMethodException, IllegalAccessException, InvocationTargetException,
+            InstantiationException {
         if (null == args) {
             args = ArrayUtils.EMPTY_OBJECT_ARRAY;
         }
@@ -167,14 +178,14 @@ public class ConstructorUtils {
      * <p>Returns new instance of <code>klazz</code> created using constructor
      * with signature <code>parameterTypes</code> and actual arguments
      * <code>args</code>.</p>
-     *
+     * 
      * <p>The signatures should match exactly.</p>
-     *
+     * 
      * @param cls the class to be constructed.
      * @param args actual argument array
      * @param parameterTypes parameter types array
      * @return new instance of <code>klazz</code>
-     *
+     * 
      * @throws NoSuchMethodException if matching constructor cannot be found
      * @throws IllegalAccessException thrown on the constructor's invocation
      * @throws InvocationTargetException thrown on the constructor's invocation
@@ -182,9 +193,8 @@ public class ConstructorUtils {
      * @see Constructor#newInstance
      */
     public static <T> T invokeExactConstructor(Class<T> cls, Object[] args,
-            Class<?>[] parameterTypes) throws NoSuchMethodException,
-            IllegalAccessException, InvocationTargetException,
-            InstantiationException {
+            Class<?>[] parameterTypes) throws NoSuchMethodException, IllegalAccessException,
+            InvocationTargetException, InstantiationException {
         if (args == null) {
             args = ArrayUtils.EMPTY_OBJECT_ARRAY;
         }
@@ -193,9 +203,8 @@ public class ConstructorUtils {
         }
         Constructor<T> ctor = getAccessibleConstructor(cls, parameterTypes);
         if (null == ctor) {
-            throw new NoSuchMethodException(
-                    "No such accessible constructor on object: "
-                            + cls.getName());
+            throw new NoSuchMethodException("No such accessible constructor on object: "
+                    + cls.getName());
         }
         return ctor.newInstance(args);
     }
@@ -225,24 +234,24 @@ public class ConstructorUtils {
      */
     public static <T> Constructor<T> getAccessibleConstructor(Constructor<T>
ctor) {
         return MemberUtils.isAccessible(ctor)
-                && Modifier.isPublic(ctor.getDeclaringClass().getModifiers()) ? ctor
-                : null;
+                && Modifier.isPublic(ctor.getDeclaringClass().getModifiers()) ? ctor
: null;
     }
 
     /**
-     * <p>Find an accessible constructor with compatible parameters.
-     * Compatible parameters mean that every method parameter is assignable from
-     * the given parameters. In other words, it finds constructor that will take
-     * the parameters given.</p>
-     *
+     * <p>Find an accessible constructor with compatible parameters. Compatible
+     * parameters mean that every method parameter is assignable from the given
+     * parameters. In other words, it finds constructor that will take the
+     * parameters given.</p>
+     * 
      * <p>First it checks if there is constructor matching the exact signature.
-     * If no such, all the constructors of the class are tested if their signatures
-     * are assignment compatible with the parameter types.
-     * The first matching constructor is returned.</p>
-     *
+     * If no such, all the constructors of the class are tested if their
+     * signatures are assignment compatible with the parameter types. The first
+     * matching constructor is returned.</p>
+     * 
      * @param cls find constructor for this class
      * @param parameterTypes find method with compatible parameters
-     * @return a valid Constructor object. If there's no matching constructor, returns <code>null</code>.
+     * @return a valid Constructor object. If there's no matching constructor,
+     * returns <code>null</code>.
      */
     public static <T> Constructor<T> getMatchingAccessibleConstructor(Class<T>
cls,
             Class<?>... parameterTypes) {
@@ -255,20 +264,23 @@ public class ConstructorUtils {
         } catch (NoSuchMethodException e) { /* SWALLOW */
         }
         Constructor<T> result = null;
-        // search through all constructors
-        Constructor<?>[] ctors = cls.getConstructors();
-        for (int i = 0; i < ctors.length; i++) {
+        /*
+         * Class.getConstructors() is documented to return Constructor<T> so as
+         * long as the array is not subsequently modified, everything's fine:
+         */
+        @SuppressWarnings("unchecked")
+        Constructor<T>[] ctors = (Constructor<T>[]) cls.getConstructors();
+
+        // return best match:
+        for (Constructor<T> ctor : ctors) {
             // compare parameters
-            if (ClassUtils.isAssignable(parameterTypes, ctors[i]
-                    .getParameterTypes(), true)) {
-                // get accessible version of method
-                @SuppressWarnings("unchecked") // TODO is this OK? If so, why?
-                Constructor<T> ctor = getAccessibleConstructor((Constructor<T>)
ctors[i]);
+            if (ClassUtils.isAssignable(parameterTypes, ctor.getParameterTypes(), true))
{
+                // get accessible version of constructor
+                ctor = getAccessibleConstructor(ctor);
                 if (ctor != null) {
                     MemberUtils.setAccessibleWorkaround(ctor);
                     if (result == null
-                            || MemberUtils.compareParameterTypes(ctor
-                                    .getParameterTypes(), result
+                            || MemberUtils.compareParameterTypes(ctor.getParameterTypes(),
result
                                     .getParameterTypes(), parameterTypes) < 0) {
                         result = ctor;
                     }



Mime
View raw message