You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@commons.apache.org by mb...@apache.org on 2010/08/09 18:20:55 UTC
svn commit: r983709 -
/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
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;
}
Re: svn commit: r983709 - /commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/reflect/ConstructorUtils.java
Posted by Matt Benson <gu...@gmail.com>.
Argh, sorry for the comment reformatting. Let me know if somebody feels they need me to revert and redo. -Matt
On Aug 9, 2010, at 11:20 AM, mbenson@apache.org wrote:
> 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;
> }
>
>
---------------------------------------------------------------------
To unsubscribe, e-mail: dev-unsubscribe@commons.apache.org
For additional commands, e-mail: dev-help@commons.apache.org