You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by sc...@apache.org on 2002/12/15 20:36:08 UTC
cvs commit: jakarta-commons/lang/src/java/org/apache/commons/lang ClassUtils.java
scolebourne 2002/12/15 11:36:08
Modified: lang/src/test/org/apache/commons/lang LangTestSuite.java
lang/src/java/org/apache/commons/lang ClassUtils.java
Added: lang/src/test/org/apache/commons/lang ClassUtilsTest.java
Log:
Test the ClassUtils class
Revision Changes Path
1.8 +2 -1 jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java
Index: LangTestSuite.java
===================================================================
RCS file: /home/cvs/jakarta-commons/lang/src/test/org/apache/commons/lang/LangTestSuite.java,v
retrieving revision 1.7
retrieving revision 1.8
diff -u -r1.7 -r1.8
--- LangTestSuite.java 15 Dec 2002 16:55:32 -0000 1.7
+++ LangTestSuite.java 15 Dec 2002 19:36:08 -0000 1.8
@@ -89,6 +89,7 @@
suite.addTest(ArrayUtilsTest.suite());
suite.addTest(BooleanUtilsTest.suite());
suite.addTest(CharSetUtilsTest.suite());
+ suite.addTest(ClassUtilsTest.suite());
suite.addTest(NumberRangeTest.suite());
suite.addTest(NumberUtilsTest.suite());
suite.addTest(ObjectUtilsTest.suite());
1.1 jakarta-commons/lang/src/test/org/apache/commons/lang/ClassUtilsTest.java
Index: ClassUtilsTest.java
===================================================================
/* ====================================================================
* The Apache Software License, Version 1.1
*
* Copyright (c) 2002 The Apache Software Foundation. All rights
* reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in
* the documentation and/or other materials provided with the
* distribution.
*
* 3. The end-user documentation included with the redistribution, if
* any, must include the following acknowlegement:
* "This product includes software developed by the
* Apache Software Foundation (http://www.apache.org/)."
* Alternately, this acknowlegement may appear in the software itself,
* if and wherever such third-party acknowlegements normally appear.
*
* 4. The names "The Jakarta Project", "Commons", and "Apache Software
* Foundation" must not be used to endorse or promote products derived
* from this software without prior written permission. For written
* permission, please contact apache@apache.org.
*
* 5. Products derived from this software may not be called "Apache"
* nor may "Apache" appear in their names without prior written
* permission of the Apache Software Foundation.
*
* THIS SOFTWARE IS PROVIDED ``AS IS'' AND ANY EXPRESSED OR IMPLIED
* WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
* OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL THE APACHE SOFTWARE FOUNDATION OR
* ITS CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
* SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
* LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF
* USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT
* OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
* SUCH DAMAGE.
* ====================================================================
*
* This software consists of voluntary contributions made by many
* individuals on behalf of the Apache Software Foundation. For more
* information on the Apache Software Foundation, please see
* <http://www.apache.org/>.
*/
package org.apache.commons.lang;
import java.util.ArrayList;
import java.util.List;
import java.util.Map;
import junit.framework.Test;
import junit.framework.TestCase;
import junit.framework.TestSuite;
import junit.textui.TestRunner;
/**
* Unit tests {@link org.apache.commons.lang.ClassUtils}.
*
* @author Stephen Colebourne
* @version $Id: ClassUtilsTest.java,v 1.1 2002/12/15 19:36:08 scolebourne Exp $
*/
public class ClassUtilsTest extends TestCase {
public ClassUtilsTest(String name) {
super(name);
}
public static void main(String[] args) {
TestRunner.run(suite());
}
public static Test suite() {
TestSuite suite = new TestSuite(ClassUtilsTest.class);
suite.setName("ClassUtils Tests");
return suite;
}
protected void setUp() throws Exception {
super.setUp();
}
protected void tearDown() throws Exception {
super.tearDown();
}
private static class Inner {
}
// -------------------------------------------------------------------------
public void test_getShortClassName_Object() {
assertEquals("ClassUtils", ClassUtils.getShortClassName(new ClassUtils(), "<null>"));
assertEquals("ClassUtilsTest.Inner", ClassUtils.getShortClassName(new Inner(), "<null>"));
assertEquals("String", ClassUtils.getShortClassName("hello", "<null>"));
assertEquals("<null>", ClassUtils.getShortClassName(null, "<null>"));
}
public void test_getShortClassName_Class() {
assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class));
assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class));
try {
ClassUtils.getShortClassName((Class) null);
fail();
} catch (IllegalArgumentException ex) {}
}
public void test_getShortClassName_String() {
assertEquals("ClassUtils", ClassUtils.getShortClassName(ClassUtils.class.getName()));
assertEquals("Map.Entry", ClassUtils.getShortClassName(Map.Entry.class.getName()));
try {
ClassUtils.getShortClassName((String) null);
fail();
} catch (IllegalArgumentException ex) {}
try {
ClassUtils.getShortClassName("");
fail();
} catch (IllegalArgumentException ex) {}
}
// -------------------------------------------------------------------------
public void test_getPackageName_Object() {
assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(new ClassUtils(), "<null>"));
assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(new Inner(), "<null>"));
assertEquals("<null>", ClassUtils.getPackageName(null, "<null>"));
}
public void test_getPackageName_Class() {
assertEquals("java.lang", ClassUtils.getPackageName(String.class));
assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class));
try {
ClassUtils.getPackageName((Class) null);
fail();
} catch (IllegalArgumentException ex) {}
}
public void test_getPackageName_String() {
assertEquals("org.apache.commons.lang", ClassUtils.getPackageName(ClassUtils.class.getName()));
assertEquals("java.util", ClassUtils.getPackageName(Map.Entry.class.getName()));
try {
ClassUtils.getPackageName((String) null);
fail();
} catch (IllegalArgumentException ex) {}
try {
ClassUtils.getPackageName("");
fail();
} catch (IllegalArgumentException ex) {}
}
// -------------------------------------------------------------------------
public void test_getAllSuperclasses_Class() {
List list = ClassUtils.getAllSuperclasses(CY.class);
assertEquals(2, list.size());
assertEquals(CX.class, list.get(0));
assertEquals(Object.class, list.get(1));
try {
ClassUtils.getAllSuperclasses(null);
fail();
} catch (IllegalArgumentException ex) {}
}
public void test_getAllInterfaces_Class() {
List list = ClassUtils.getAllInterfaces(CY.class);
assertEquals(6, list.size());
assertEquals(IB.class, list.get(0));
assertEquals(IC.class, list.get(1));
assertEquals(ID.class, list.get(2));
assertEquals(IE.class, list.get(3));
assertEquals(IF.class, list.get(4));
assertEquals(IA.class, list.get(5));
try {
ClassUtils.getAllInterfaces(null);
fail();
} catch (IllegalArgumentException ex) {}
}
private static interface IA {
}
private static interface IB {
}
private static interface IC extends ID, IE {
}
private static interface ID {
}
private static interface IE extends IF {
}
private static interface IF {
}
private static class CX implements IB, IA, IE {
}
private static class CY extends CX implements IB, IC {
}
// -------------------------------------------------------------------------
public void test_convertClassNamesToClasses_List() {
List list = new ArrayList();
List result = ClassUtils.convertClassNamesToClasses(list);
assertEquals(0, result.size());
list.add("java.lang.String");
list.add("java.lang.xxx");
list.add("java.lang.Object");
result = ClassUtils.convertClassNamesToClasses(list);
assertEquals(3, result.size());
assertEquals(String.class, result.get(0));
assertEquals(null, result.get(1));
assertEquals(Object.class, result.get(2));
list.add(new Object());
try {
ClassUtils.convertClassNamesToClasses(list);
fail();
} catch (ClassCastException ex) {}
try {
ClassUtils.convertClassNamesToClasses(null);
fail();
} catch (IllegalArgumentException ex) {}
}
public void test_convertClassesToClassNames_List() {
List list = new ArrayList();
List result = ClassUtils.convertClassesToClassNames(list);
assertEquals(0, result.size());
list.add(String.class);
list.add(Object.class);
result = ClassUtils.convertClassesToClassNames(list);
assertEquals(2, result.size());
assertEquals("java.lang.String", result.get(0));
assertEquals("java.lang.Object", result.get(1));
list.add(new Object());
try {
ClassUtils.convertClassesToClassNames(list);
fail();
} catch (ClassCastException ex) {}
try {
ClassUtils.convertClassesToClassNames(null);
fail();
} catch (IllegalArgumentException ex) {}
}
// -------------------------------------------------------------------------
public void test_isInnerClass_Class() {
assertEquals(true, ClassUtils.isInnerClass(Inner.class));
assertEquals(true, ClassUtils.isInnerClass(Map.Entry.class));
assertEquals(false, ClassUtils.isInnerClass(this.getClass()));
assertEquals(false, ClassUtils.isInnerClass(String.class));
try {
ClassUtils.isInnerClass(null);
fail();
} catch (IllegalArgumentException ex) {}
}
// -------------------------------------------------------------------------
public void test_isAssignable_ClassArray_ClassArray() throws Exception {
Class[] array2 = new Class[] {Object.class, Object.class};
Class[] array1 = new Class[] {Object.class};
Class[] array1s = new Class[] {String.class};
Class[] array0 = new Class[] {};
assertEquals(false, ClassUtils.isAssignable(array1, array2));
assertEquals(false, ClassUtils.isAssignable(null, array2));
assertEquals(true, ClassUtils.isAssignable(null, array0));
assertEquals(true, ClassUtils.isAssignable(array0, array0));
assertEquals(true, ClassUtils.isAssignable(array0, null));
assertEquals(true, ClassUtils.isAssignable((Class[]) null, (Class[]) null));
assertEquals(false, ClassUtils.isAssignable(array1, array1s));
assertEquals(true, ClassUtils.isAssignable(array1s, array1s));
assertEquals(true, ClassUtils.isAssignable(array1s, array1));
}
public void test_isAssignable() throws Exception {
try {
ClassUtils.isAssignable(String.class, null);
fail();
} catch (IllegalArgumentException ex) {}
try {
ClassUtils.isAssignable((Class) null, (Class) null);
fail();
} catch (IllegalArgumentException ex) {}
assertEquals(true, ClassUtils.isAssignable(null, Object.class));
assertEquals(true, ClassUtils.isAssignable(null, Integer.class));
assertEquals(false, ClassUtils.isAssignable(null, Integer.TYPE));
assertEquals(true, ClassUtils.isAssignable(String.class, Object.class));
assertEquals(true, ClassUtils.isAssignable(String.class, String.class));
assertEquals(false, ClassUtils.isAssignable(Object.class, String.class));
assertEquals(false, ClassUtils.isAssignable(Integer.TYPE, Integer.class));
assertEquals(false, ClassUtils.isAssignable(Integer.class, Integer.TYPE));
assertEquals(true, ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
assertEquals(true, ClassUtils.isAssignable(Integer.class, Integer.class));
}
public void test_isAssignable_Widening() throws Exception {
// test byte conversions
assertEquals("byte -> char", false, ClassUtils.isAssignable(Byte.TYPE, Character.TYPE));
assertEquals("byte -> byte", true, ClassUtils.isAssignable(Byte.TYPE, Byte.TYPE));
assertEquals("byte -> short", true, ClassUtils.isAssignable(Byte.TYPE, Short.TYPE));
assertEquals("byte -> int", true, ClassUtils.isAssignable(Byte.TYPE, Integer.TYPE));
assertEquals("byte -> long", true, ClassUtils.isAssignable(Byte.TYPE, Long.TYPE));
assertEquals("byte -> float", true, ClassUtils.isAssignable(Byte.TYPE, Float.TYPE));
assertEquals("byte -> double", true, ClassUtils.isAssignable(Byte.TYPE, Double.TYPE));
assertEquals("byte -> boolean", false, ClassUtils.isAssignable(Byte.TYPE, Boolean.TYPE));
// test short conversions
assertEquals("short -> char", false, ClassUtils.isAssignable(Short.TYPE, Character.TYPE));
assertEquals("short -> byte", false, ClassUtils.isAssignable(Short.TYPE, Byte.TYPE));
assertEquals("short -> short", true, ClassUtils.isAssignable(Short.TYPE, Short.TYPE));
assertEquals("short -> int", true, ClassUtils.isAssignable(Short.TYPE, Integer.TYPE));
assertEquals("short -> long", true, ClassUtils.isAssignable(Short.TYPE, Long.TYPE));
assertEquals("short -> float", true, ClassUtils.isAssignable(Short.TYPE, Float.TYPE));
assertEquals("short -> double", true, ClassUtils.isAssignable(Short.TYPE, Double.TYPE));
assertEquals("short -> boolean", false, ClassUtils.isAssignable(Short.TYPE, Boolean.TYPE));
// test char conversions
assertEquals("char -> char", true, ClassUtils.isAssignable(Character.TYPE, Character.TYPE));
assertEquals("char -> byte", false, ClassUtils.isAssignable(Character.TYPE, Byte.TYPE));
assertEquals("char -> short", false, ClassUtils.isAssignable(Character.TYPE, Short.TYPE));
assertEquals("char -> int", true, ClassUtils.isAssignable(Character.TYPE, Integer.TYPE));
assertEquals("char -> long", true, ClassUtils.isAssignable(Character.TYPE, Long.TYPE));
assertEquals("char -> float", true, ClassUtils.isAssignable(Character.TYPE, Float.TYPE));
assertEquals("char -> double", true, ClassUtils.isAssignable(Character.TYPE, Double.TYPE));
assertEquals("char -> boolean", false, ClassUtils.isAssignable(Character.TYPE, Boolean.TYPE));
// test int conversions
assertEquals("int -> char", false, ClassUtils.isAssignable(Integer.TYPE, Character.TYPE));
assertEquals("int -> byte", false, ClassUtils.isAssignable(Integer.TYPE, Byte.TYPE));
assertEquals("int -> short", false, ClassUtils.isAssignable(Integer.TYPE, Short.TYPE));
assertEquals("int -> int", true, ClassUtils.isAssignable(Integer.TYPE, Integer.TYPE));
assertEquals("int -> long", true, ClassUtils.isAssignable(Integer.TYPE, Long.TYPE));
assertEquals("int -> float", true, ClassUtils.isAssignable(Integer.TYPE, Float.TYPE));
assertEquals("int -> double", true, ClassUtils.isAssignable(Integer.TYPE, Double.TYPE));
assertEquals("int -> boolean", false, ClassUtils.isAssignable(Integer.TYPE, Boolean.TYPE));
// test long conversions
assertEquals("long -> char", false, ClassUtils.isAssignable(Long.TYPE, Character.TYPE));
assertEquals("long -> byte", false, ClassUtils.isAssignable(Long.TYPE, Byte.TYPE));
assertEquals("long -> short", false, ClassUtils.isAssignable(Long.TYPE, Short.TYPE));
assertEquals("long -> int", false, ClassUtils.isAssignable(Long.TYPE, Integer.TYPE));
assertEquals("long -> long", true, ClassUtils.isAssignable(Long.TYPE, Long.TYPE));
assertEquals("long -> float", true, ClassUtils.isAssignable(Long.TYPE, Float.TYPE));
assertEquals("long -> double", true, ClassUtils.isAssignable(Long.TYPE, Double.TYPE));
assertEquals("long -> boolean", false, ClassUtils.isAssignable(Long.TYPE, Boolean.TYPE));
// test float conversions
assertEquals("float -> char", false, ClassUtils.isAssignable(Float.TYPE, Character.TYPE));
assertEquals("float -> byte", false, ClassUtils.isAssignable(Float.TYPE, Byte.TYPE));
assertEquals("float -> short", false, ClassUtils.isAssignable(Float.TYPE, Short.TYPE));
assertEquals("float -> int", false, ClassUtils.isAssignable(Float.TYPE, Integer.TYPE));
assertEquals("float -> long", false, ClassUtils.isAssignable(Float.TYPE, Long.TYPE));
assertEquals("float -> float", true, ClassUtils.isAssignable(Float.TYPE, Float.TYPE));
assertEquals("float -> double", true, ClassUtils.isAssignable(Float.TYPE, Double.TYPE));
assertEquals("float -> boolean", false, ClassUtils.isAssignable(Float.TYPE, Boolean.TYPE));
// test float conversions
assertEquals("double -> char", false, ClassUtils.isAssignable(Double.TYPE, Character.TYPE));
assertEquals("double -> byte", false, ClassUtils.isAssignable(Double.TYPE, Byte.TYPE));
assertEquals("double -> short", false, ClassUtils.isAssignable(Double.TYPE, Short.TYPE));
assertEquals("double -> int", false, ClassUtils.isAssignable(Double.TYPE, Integer.TYPE));
assertEquals("double -> long", false, ClassUtils.isAssignable(Double.TYPE, Long.TYPE));
assertEquals("double -> float", false, ClassUtils.isAssignable(Double.TYPE, Float.TYPE));
assertEquals("double -> double", true, ClassUtils.isAssignable(Double.TYPE, Double.TYPE));
assertEquals("double -> boolean", false, ClassUtils.isAssignable(Double.TYPE, Boolean.TYPE));
// test float conversions
assertEquals("boolean -> char", false, ClassUtils.isAssignable(Boolean.TYPE, Character.TYPE));
assertEquals("boolean -> byte", false, ClassUtils.isAssignable(Boolean.TYPE, Byte.TYPE));
assertEquals("boolean -> short", false, ClassUtils.isAssignable(Boolean.TYPE, Short.TYPE));
assertEquals("boolean -> int", false, ClassUtils.isAssignable(Boolean.TYPE, Integer.TYPE));
assertEquals("boolean -> long", false, ClassUtils.isAssignable(Boolean.TYPE, Long.TYPE));
assertEquals("boolean -> float", false, ClassUtils.isAssignable(Boolean.TYPE, Float.TYPE));
assertEquals("boolean -> double", false, ClassUtils.isAssignable(Boolean.TYPE, Double.TYPE));
assertEquals("boolean -> boolean", true, ClassUtils.isAssignable(Boolean.TYPE, Boolean.TYPE));
}
// public static List getAssignableFrom(List classes, Class superclass) {
// public static boolean isAssignable(Class[] classArray, Class[] toClassArray) {
// public static boolean isAssignable(Class cls, Class toClass) {
}
1.6 +75 -73 jakarta-commons/lang/src/java/org/apache/commons/lang/ClassUtils.java
Index: ClassUtils.java
===================================================================
RCS file: /home/cvs/jakarta-commons/lang/src/java/org/apache/commons/lang/ClassUtils.java,v
retrieving revision 1.5
retrieving revision 1.6
diff -u -r1.5 -r1.6
--- ClassUtils.java 16 Nov 2002 10:41:03 -0000 1.5
+++ ClassUtils.java 15 Dec 2002 19:36:08 -0000 1.6
@@ -79,8 +79,21 @@
// -------------------------------------------------------------------------
/**
- * <p>Gets the class name minus the package name from a
- * <code>Class</code>.</p>
+ * <p>Gets the class name minus the package name for an <code>Object</code>.</p>
+ *
+ * @param object the class to get the short name for
+ * @param valueIfNull the value to return if null
+ * @return the class name of the object without the package name, or the null value
+ */
+ public static String getShortClassName(Object object, String valueIfNull) {
+ if (object == null) {
+ return valueIfNull;
+ }
+ return getShortClassName(object.getClass().getName());
+ }
+
+ /**
+ * <p>Gets the class name minus the package name from a <code>Class</code>.</p>
*
* @param cls the class to get the short name for, must not be
* <code>null</code>
@@ -95,22 +108,6 @@
}
/**
- * <p>Gets the class name minus the package name for an
- * <code>Object</code>.</p>
- *
- * @param object the class to get the short name for, must not be
- * <code>null</code>
- * @return the class name of the object without the package name
- * @throws IllegalArgumentException if the object is <code>null</code>
- */
- public static String getShortClassName(Object object) {
- if (object == null) {
- throw new IllegalArgumentException("The object must not be null");
- }
- return getShortClassName(object.getClass().getName());
- }
-
- /**
* <p>Gets the class name minus the package name from a String.</p>
*
* <p>The string passed in is assumed to be a class name - it is not checked.</p>
@@ -138,6 +135,20 @@
// -------------------------------------------------------------------------
/**
+ * <p>Gets the package name of an <code>Object</code>.</p>
+ *
+ * @param object the class to get the package name for
+ * @param valueIfNull the value to return if null
+ * @return the package name of the object, or the null value
+ */
+ public static String getPackageName(Object object, String valueIfNull) {
+ if (object == null) {
+ return valueIfNull;
+ }
+ return getPackageName(object.getClass().getName());
+ }
+
+ /**
* <p>Gets the package name of a <code>Class</code>.</p>
*
* @param cls the class to get the package name for, must not be
@@ -153,21 +164,6 @@
}
/**
- * <p>Gets the package name of an <code>Object</code>.</p>
- *
- * @param object the class to get the package name for, must not be
- * <code>null</code>
- * @return the package name
- * @throws IllegalArgumentException if the object is <code>null</code>
- */
- public static String getPackageName(Object object) {
- if (object == null) {
- throw new IllegalArgumentException("The object must not be null");
- }
- return getPackageName(object.getClass().getName());
- }
-
- /**
* <p>Gets the package name from a <code>String</code>.</p>
*
* <p>The string passed in is assumed to be a class name - it is not checked.</p>
@@ -211,11 +207,12 @@
/**
* <p>Gets a <code>List</code> of all interfaces implemented by the given
- * class.</p>
+ * class and its superclasses.</p>
*
* <p>The order is determined by looking through each interface in turn as
- * declared in the source file and following its hieracrchy up. Later
- * duplicates are ignored, so the order is maintained.</p>
+ * declared in the source file and following its hieracrchy up. Then each
+ * superclass is considered in the same way. Later duplicates are ignored,
+ * so the order is maintained.</p>
*
* @param cls the class to look up, must not be <code>null</code>
* @return the <code>List</code> of interfaces in order
@@ -226,18 +223,21 @@
throw new IllegalArgumentException("The class must not be null");
}
List list = new ArrayList();
- Class[] interfaces = cls.getInterfaces();
- for (int i = 0; i < interfaces.length; i++) {
- if (list.contains(interfaces[i]) == false) {
- list.add(interfaces[i]);
- }
- List superInterfaces = getAllInterfaces(interfaces[i]);
- for (Iterator it = superInterfaces.iterator(); it.hasNext();) {
- Class intface = (Class) it.next();
- if (list.contains(intface) == false) {
- list.add(intface);
+ while (cls != null) {
+ Class[] interfaces = cls.getInterfaces();
+ for (int i = 0; i < interfaces.length; i++) {
+ if (list.contains(interfaces[i]) == false) {
+ list.add(interfaces[i]);
+ }
+ List superInterfaces = getAllInterfaces(interfaces[i]);
+ for (Iterator it = superInterfaces.iterator(); it.hasNext();) {
+ Class intface = (Class) it.next();
+ if (list.contains(intface) == false) {
+ list.add(intface);
+ }
}
}
+ cls = cls.getSuperclass();
}
return list;
}
@@ -295,17 +295,18 @@
// return null;
// }
+ // -------------------------------------------------------------------------
+
/**
* <p>Given a <code>List</code> of class names, this method converts them into classes. *
* A new <code>List</code> is returned. If the class name cannot be found, <code>null</code>
* is stored in the <code>List</code>. If the class name in the <code>List</code> is
* <code>null</code>, <code>null</code> is stored in the output <code>List</code>.</p>
*
- * @param classNames the classNames to change, the class is stored back
- * into the <code>List</code>. <code>null</code> will be stored in the <code>List</code>
- * if no class is found.
- * @return the <code>List</code> of Class objects corresponding to the class names
+ * @param classNames the classNames to change
+ * @return a <code>List</code> of Class objects corresponding to the class names
* @throws IllegalArgumentException if the classNames is <code>null</code>
+ * @throws ClassCastException if classNames contains a non String entry
*/
public static List convertClassNamesToClasses(List classNames) {
if (classNames == null) {
@@ -324,40 +325,41 @@
}
/**
- * <p>Given a <code>List</code> of classes, this method finds all those which
- * are subclasses or implementations of a specified superclass.</p>
+ * <p>Given a <code>List</code> of <code>Class</code> objects, this method converts
+ * them into class names.
+ * A new <code>List</code> is returned. <code>null</code> objects will be copied into
+ * the returned list as <code>null</code>.</p>
*
- * @param classes the classes to check
- * @param superclass the superclass to check for
- * @return the list of subclasses or implementations
- * @throws IllegalArgumentException if the classes or superClass is <code>null</code>
+ * @param classes the classes to change
+ * @return a <code>List</code> of Class objects corresponding to the class names
+ * @throws IllegalArgumentException if the classNames is <code>null</code>
+ * @throws ClassCastException if classNames contains a non Class or null entry
*/
- public static List getAssignableFrom(List classes, Class superclass) {
+ public static List convertClassesToClassNames(List classes) {
if (classes == null) {
- throw new IllegalArgumentException("The classes must not be null");
+ throw new IllegalArgumentException("The classes list must not be null");
}
- if (superclass == null) {
- throw new IllegalArgumentException("The superclass must not be null");
- }
- List subs = new ArrayList();
- Iterator it = classes.iterator();
- while (it.hasNext()) {
+ List classNames = new ArrayList(classes.size());
+ for (Iterator it = classes.iterator(); it.hasNext();) {
Class cls = (Class) it.next();
if (cls == null) {
- throw new IllegalArgumentException("The class list must not contain nulls");
- }
- if (isAssignable(cls, superclass)) {
- subs.add(cls);
+ classNames.add(null);
+ } else {
+ classNames.add(cls.getName());
}
}
- return subs;
+ return classNames;
}
-
+
+ // -------------------------------------------------------------------------
+
/**
* <p>Checks if an array of Classes can be assigned to another array of Classes.</p>
*
- * <p>This can be used to check if parameter types are suitably compatable for
- * reflection invocation.</p>
+ * <p>This method calls {@link #isAssignable(Class, Class) isAssignable} for each
+ * Class pair in the input arrays. It can be used to check if a set of arguments
+ * (the first parameter) are suitably compatable with a set of method parameter types
+ * (the second parameter).</p>
*
* <p>Unlike the {@link Class#isAssignableFrom(java.lang.Class)} method, this
* method takes into account widenings of primitive classes and
--
To unsubscribe, e-mail: <ma...@jakarta.apache.org>
For additional commands, e-mail: <ma...@jakarta.apache.org>