Author: jcarman
Date: Thu Nov 17 08:51:02 2005
New Revision: 345284
URL: http://svn.apache.org/viewcvs?rev=345284&view=rev
Log:
Refactored getClass() to support spaces in class names.
Modified:
jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtils.java
jakarta/commons/proper/lang/trunk/src/test/org/apache/commons/lang/ClassUtilsTest.java
Modified:
jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtils.java
URL:
http://svn.apache.org/viewcvs/jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtils.java?rev=345284&r1=345283&r2=345284&view=diff
==============================================================================
---
jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtils.java
(original)
+++
jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtils.java
Thu Nov 17 08:51:02 2005
@@ -23,223 +23,264 @@
/**
* <p>Operates on classes without using reflection.</p>
- *
- * <p>This class handles invalid <code>null</code> inputs as best it can.
- * Each method documents its behaviour in more detail.</p>
+ * <p/>
+ * <p>This class handles invalid <code>null</code> inputs as best it can. Each
method documents its behaviour in more
+ * detail.</p>
*
* @author Stephen Colebourne
* @author Gary Gregory
* @author Norm Deane
* @author Alban Peignier
- * @since 2.0
* @version $Id$
+ * @since 2.0
*/
-public class ClassUtils {
-
+public class ClassUtils
+{
/**
* <p>The package separator character: <code>'.' == [EMAIL
PROTECTED]</code>.</p>
*/
public static final char PACKAGE_SEPARATOR_CHAR = '.';
-
/**
* <p>The package separator String: <code>"."</code>.</p>
*/
- public static final String PACKAGE_SEPARATOR =
String.valueOf(PACKAGE_SEPARATOR_CHAR);
-
+ public static final String PACKAGE_SEPARATOR = String.valueOf(
PACKAGE_SEPARATOR_CHAR );
/**
* <p>The inner class separator character: <code>'$' == [EMAIL
PROTECTED]</code>.</p>
*/
public static final char INNER_CLASS_SEPARATOR_CHAR = '$';
-
/**
* <p>The inner class separator String: <code>"$"</code>.</p>
*/
- public static final String INNER_CLASS_SEPARATOR =
String.valueOf(INNER_CLASS_SEPARATOR_CHAR);
-
- /**
- * Maps primitive <code>Class</code>es to their corresponding wrapper
<code>Class</code>.
- */
- private static Map primitiveWrapperMap = new HashMap();
- static {
- primitiveWrapperMap.put(Boolean.TYPE, Boolean.class);
- primitiveWrapperMap.put(Byte.TYPE, Byte.class);
- primitiveWrapperMap.put(Character.TYPE, Character.class);
- primitiveWrapperMap.put(Short.TYPE, Short.class);
- primitiveWrapperMap.put(Integer.TYPE, Integer.class);
- primitiveWrapperMap.put(Long.TYPE, Long.class);
- primitiveWrapperMap.put(Double.TYPE, Double.class);
- primitiveWrapperMap.put(Float.TYPE, Float.class);
- primitiveWrapperMap.put(Void.TYPE, Void.TYPE);
+ public static final String INNER_CLASS_SEPARATOR = String.valueOf(
INNER_CLASS_SEPARATOR_CHAR );
+ /**
+ * Maps primitive <code>Class</code>es to their corresponding wrapper
<code>Class</code>.
+ */
+ private static Map primitiveWrapperMap = new HashMap();
+
+ static
+ {
+ primitiveWrapperMap.put( Boolean.TYPE, Boolean.class );
+ primitiveWrapperMap.put( Byte.TYPE, Byte.class );
+ primitiveWrapperMap.put( Character.TYPE, Character.class );
+ primitiveWrapperMap.put( Short.TYPE, Short.class );
+ primitiveWrapperMap.put( Integer.TYPE, Integer.class );
+ primitiveWrapperMap.put( Long.TYPE, Long.class );
+ primitiveWrapperMap.put( Double.TYPE, Double.class );
+ primitiveWrapperMap.put( Float.TYPE, Float.class );
+ primitiveWrapperMap.put( Void.TYPE, Void.TYPE );
+ }
+
+ /**
+ * Maps a primitive class name to its corresponding abbreviation used in
array class names.
+ */
+ private static Map abbreviationMap = new HashMap();
+
+ static
+ {
+ abbreviationMap.put( "int", "I" );
+ abbreviationMap.put( "boolean", "Z" );
+ abbreviationMap.put( "float", "F" );
+ abbreviationMap.put( "long", "J" );
+ abbreviationMap.put( "short", "S" );
+ abbreviationMap.put( "byte", "B" );
+ abbreviationMap.put( "double", "D" );
+ abbreviationMap.put( "char", "C" );
}
-
+
/**
- * <p>ClassUtils instances should NOT be constructed in standard
programming.
- * Instead, the class should be used as
+ * <p>ClassUtils instances should NOT be constructed in standard
programming. Instead, the class should be used as
* <code>ClassUtils.getShortClassName(cls)</code>.</p>
- *
- * <p>This constructor is public to permit tools that require a JavaBean
- * instance to operate.</p>
+ * <p/>
+ * <p>This constructor is public to permit tools that require a JavaBean
instance to operate.</p>
*/
- public ClassUtils() {
- super();
+ public ClassUtils()
+ {
+ super();
}
// Short class name
// ----------------------------------------------------------------------
+
/**
* <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, may be null
- * @param valueIfNull the value to return if null
+ *
+ * @param object the class to get the short name for, may be null
+ * @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) {
+ public static String getShortClassName( Object object, String valueIfNull )
+ {
+ if( object == null )
+ {
return valueIfNull;
}
- return getShortClassName(object.getClass().getName());
+ 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.
+ *
+ * @param cls the class to get the short name for.
* @return the class name without the package name or an empty string
*/
- public static String getShortClassName(Class cls) {
- if (cls == null) {
+ public static String getShortClassName( Class cls )
+ {
+ if( cls == null )
+ {
return StringUtils.EMPTY;
}
- return getShortClassName(cls.getName());
+ return getShortClassName( cls.getName() );
}
-
+
/**
* <p>Gets the class name minus the package name from a String.</p>
- *
+ * <p/>
* <p>The string passed in is assumed to be a class name - it is not
checked.</p>
- *
- * @param className the className to get the short name for
+ *
+ * @param className the className to get the short name for
* @return the class name of the class without the package name or an
empty string
*/
- public static String getShortClassName(String className) {
- if (className == null) {
+ public static String getShortClassName( String className )
+ {
+ if( className == null )
+ {
return StringUtils.EMPTY;
}
- if (className.length() == 0) {
+ if( className.length() == 0 )
+ {
return StringUtils.EMPTY;
}
char[] chars = className.toCharArray();
int lastDot = 0;
- for (int i = 0; i < chars.length; i++) {
- if (chars[i] == PACKAGE_SEPARATOR_CHAR) {
+ for( int i = 0; i < chars.length; i++ )
+ {
+ if( chars[i] == PACKAGE_SEPARATOR_CHAR )
+ {
lastDot = i + 1;
- } else if (chars[i] == INNER_CLASS_SEPARATOR_CHAR) { // handle
inner classes
+ }
+ else if( chars[i] == INNER_CLASS_SEPARATOR_CHAR )
+ { // handle inner classes
chars[i] = PACKAGE_SEPARATOR_CHAR;
}
}
- return new String(chars, lastDot, chars.length - lastDot);
+ return new String( chars, lastDot, chars.length - lastDot );
}
-
+
// Package name
// ----------------------------------------------------------------------
+
/**
* <p>Gets the package name of an <code>Object</code>.</p>
- *
- * @param object the class to get the package name for, may be null
- * @param valueIfNull the value to return if null
+ *
+ * @param object the class to get the package name for, may be null
+ * @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) {
+ public static String getPackageName( Object object, String valueIfNull )
+ {
+ if( object == null )
+ {
return valueIfNull;
}
- return getPackageName(object.getClass().getName());
+ 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, may be
<code>null</code>.
+ *
+ * @param cls the class to get the package name for, may be
<code>null</code>.
* @return the package name or an empty string
*/
- public static String getPackageName(Class cls) {
- if (cls == null) {
+ public static String getPackageName( Class cls )
+ {
+ if( cls == null )
+ {
return StringUtils.EMPTY;
}
- return getPackageName(cls.getName());
+ return getPackageName( cls.getName() );
}
-
+
/**
* <p>Gets the package name from a <code>String</code>.</p>
+ * <p/>
+ * <p>The string passed in is assumed to be a class name - it is not
checked.</p> <p>If the class is unpackaged,
+ * return an empty string.</p>
*
- * <p>The string passed in is assumed to be a class name - it is not
checked.</p>
- * <p>If the class is unpackaged, return an empty string.</p>
- *
- * @param className the className to get the package name for, may be
<code>null</code>
+ * @param className the className to get the package name for, may be
<code>null</code>
* @return the package name or an empty string
*/
- public static String getPackageName(String className) {
- if (className == null) {
+ public static String getPackageName( String className )
+ {
+ if( className == null )
+ {
return StringUtils.EMPTY;
}
- int i = className.lastIndexOf(PACKAGE_SEPARATOR_CHAR);
- if (i == -1) {
+ int i = className.lastIndexOf( PACKAGE_SEPARATOR_CHAR );
+ if( i == -1 )
+ {
return StringUtils.EMPTY;
}
- return className.substring(0, i);
+ return className.substring( 0, i );
}
-
+
// Superclasses/Superinterfaces
// ----------------------------------------------------------------------
+
/**
* <p>Gets a <code>List</code> of superclasses for the given class.</p>
- *
- * @param cls the class to look up, may be <code>null</code>
- * @return the <code>List</code> of superclasses in order going up from
this one
- * <code>null</code> if null input
+ *
+ * @param cls the class to look up, may be <code>null</code>
+ * @return the <code>List</code> of superclasses in order going up from
this one <code>null</code> if null input
*/
- public static List getAllSuperclasses(Class cls) {
- if (cls == null) {
+ public static List getAllSuperclasses( Class cls )
+ {
+ if( cls == null )
+ {
return null;
}
List classes = new ArrayList();
Class superclass = cls.getSuperclass();
- while (superclass != null) {
- classes.add(superclass);
+ while( superclass != null )
+ {
+ classes.add( superclass );
superclass = superclass.getSuperclass();
}
return classes;
}
-
+
/**
- * <p>Gets a <code>List</code> of all interfaces implemented by the given
- * 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 hierarchy 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, may be <code>null</code>
- * @return the <code>List</code> of interfaces in order,
- * <code>null</code> if null input
- */
- public static List getAllInterfaces(Class cls) {
- if (cls == null) {
+ * <p>Gets a <code>List</code> of all interfaces implemented by the given
class and its superclasses.</p>
+ * <p/>
+ * <p>The order is determined by looking through each interface in turn as
declared in the source file and following
+ * its hierarchy 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, may be <code>null</code>
+ * @return the <code>List</code> of interfaces in order, <code>null</code>
if null input
+ */
+ public static List getAllInterfaces( Class cls )
+ {
+ if( cls == null )
+ {
return null;
}
List list = new ArrayList();
- while (cls != null) {
+ 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]);
+ 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);
+ 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 );
}
}
}
@@ -247,241 +288,262 @@
}
return list;
}
-
+
// Convert list
// ----------------------------------------------------------------------
+
/**
* <p>Given a <code>List</code> of class names, this method converts them
into classes.</p>
+ * <p/>
+ * <p>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>
*
- * <p>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
- * @return a <code>List</code> of Class objects corresponding to the class
names,
- * <code>null</code> if null input
+ * @param classNames the classNames to change
+ * @return a <code>List</code> of Class objects corresponding to the class
names, <code>null</code> if null input
* @throws ClassCastException if classNames contains a non String entry
*/
- public static List convertClassNamesToClasses(List classNames) {
- if (classNames == null) {
+ public static List convertClassNamesToClasses( List classNames )
+ {
+ if( classNames == null )
+ {
return null;
}
- List classes = new ArrayList(classNames.size());
- for (Iterator it = classNames.iterator(); it.hasNext();) {
- String className = (String) it.next();
- try {
- classes.add(Class.forName(className));
- } catch (Exception ex) {
- classes.add(null);
+ List classes = new ArrayList( classNames.size() );
+ for( Iterator it = classNames.iterator(); it.hasNext(); )
+ {
+ String className = ( String ) it.next();
+ try
+ {
+ classes.add( Class.forName( className ) );
+ }
+ catch( Exception ex )
+ {
+ classes.add( null );
}
}
return classes;
}
-
+
/**
- * <p>Given a <code>List</code> of <code>Class</code> objects, this method
converts
- * them into class names.</p>
+ * <p>Given a <code>List</code> of <code>Class</code> objects, this method
converts them into class names.</p>
+ * <p/>
+ * <p>A new <code>List</code> is returned. <code>null</code> objects will
be copied into the returned list as
+ * <code>null</code>.</p>
*
- * <p>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 change
- * @return a <code>List</code> of class names corresponding to the Class
objects,
- * <code>null</code> if null input
+ * @param classes the classes to change
+ * @return a <code>List</code> of class names corresponding to the Class
objects, <code>null</code> if null input
* @throws ClassCastException if <code>classes</code> contains a
non-<code>Class</code> entry
*/
- public static List convertClassesToClassNames(List classes) {
- if (classes == null) {
+ public static List convertClassesToClassNames( List classes )
+ {
+ if( classes == null )
+ {
return null;
}
- List classNames = new ArrayList(classes.size());
- for (Iterator it = classes.iterator(); it.hasNext();) {
- Class cls = (Class) it.next();
- if (cls == null) {
- classNames.add(null);
- } else {
- classNames.add(cls.getName());
+ List classNames = new ArrayList( classes.size() );
+ for( Iterator it = classes.iterator(); it.hasNext(); )
+ {
+ Class cls = ( Class ) it.next();
+ if( cls == null )
+ {
+ classNames.add( null );
+ }
+ else
+ {
+ classNames.add( cls.getName() );
}
}
return classNames;
}
-
+
// Is assignable
// ----------------------------------------------------------------------
+
/**
* <p>Checks if an array of Classes can be assigned to another array of
Classes.</p>
+ * <p/>
+ * <p>This method calls [EMAIL PROTECTED] #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 compatible with a set of method
+ * parameter types (the second parameter).</p>
+ * <p/>
+ * <p>Unlike the [EMAIL PROTECTED] Class#isAssignableFrom(Class)} method,
this method takes into account widenings of primitive
+ * classes and <code>null</code>s.</p>
+ * <p/>
+ * <p>Primitive widenings allow an int to be assigned to a
<code>long</code>, <code>float</code> or
+ * <code>double</code>. This method returns the correct result for these
cases.</p>
+ * <p/>
+ * <p><code>Null</code> may be assigned to any reference type. This method
will return <code>true</code> if
+ * <code>null</code> is passed in and the toClass is non-primitive.</p>
+ * <p/>
+ * <p>Specifically, this method tests whether the type represented by the
specified <code>Class</code> parameter can
+ * be converted to the type represented by this <code>Class</code> object
via an identity conversion widening
+ * primitive or widening reference conversion. See <em><a
href="http://java.sun.com/docs/books/jls/";>The Java
+ * Language Specification</a></em>, sections 5.1.1, 5.1.2 and 5.1.4 for
details.</p>
*
- * <p>This method calls [EMAIL PROTECTED] #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 compatible with a set of method
parameter types
- * (the second parameter).</p>
- *
- * <p>Unlike the [EMAIL PROTECTED]
Class#isAssignableFrom(java.lang.Class)} method, this
- * method takes into account widenings of primitive classes and
- * <code>null</code>s.</p>
- *
- * <p>Primitive widenings allow an int to be assigned to a
<code>long</code>,
- * <code>float</code> or <code>double</code>. This method returns the
correct
- * result for these cases.</p>
- *
- * <p><code>Null</code> may be assigned to any reference type. This method
will
- * return <code>true</code> if <code>null</code> is passed in and the
toClass is
- * non-primitive.</p>
- *
- * <p>Specifically, this method tests whether the type represented by the
- * specified <code>Class</code> parameter can be converted to the type
- * represented by this <code>Class</code> object via an identity conversion
- * widening primitive or widening reference conversion. See
- * <em><a href="http://java.sun.com/docs/books/jls/";>The Java Language
Specification</a></em>,
- * sections 5.1.1, 5.1.2 and 5.1.4 for details.</p>
- *
- * @param classArray the array of Classes to check, may be
<code>null</code>
- * @param toClassArray the array of Classes to try to assign into, may be
<code>null</code>
+ * @param classArray the array of Classes to check, may be
<code>null</code>
+ * @param toClassArray the array of Classes to try to assign into, may be
<code>null</code>
* @return <code>true</code> if assignment possible
*/
- public static boolean isAssignable(Class[] classArray, Class[]
toClassArray) {
- if (ArrayUtils.isSameLength(classArray, toClassArray) == false) {
+ public static boolean isAssignable( Class[] classArray, Class[]
toClassArray )
+ {
+ if( ArrayUtils.isSameLength( classArray, toClassArray ) == false )
+ {
return false;
}
- if (classArray == null) {
+ if( classArray == null )
+ {
classArray = ArrayUtils.EMPTY_CLASS_ARRAY;
}
- if (toClassArray == null) {
+ if( toClassArray == null )
+ {
toClassArray = ArrayUtils.EMPTY_CLASS_ARRAY;
}
- for (int i = 0; i < classArray.length; i++) {
- if (isAssignable(classArray[i], toClassArray[i]) == false) {
+ for( int i = 0; i < classArray.length; i++ )
+ {
+ if( isAssignable( classArray[i], toClassArray[i] ) == false )
+ {
return false;
}
}
return true;
}
-
+
/**
- * <p>Checks if one <code>Class</code> can be assigned to a variable of
- * another <code>Class</code>.</p>
- *
- * <p>Unlike the [EMAIL PROTECTED]
Class#isAssignableFrom(java.lang.Class)} method,
- * this method takes into account widenings of primitive classes and
- * <code>null</code>s.</p>
- *
- * <p>Primitive widenings allow an int to be assigned to a long, float or
- * double. This method returns the correct result for these cases.</p>
- *
- * <p><code>Null</code> may be assigned to any reference type. This method
- * will return <code>true</code> if <code>null</code> is passed in and the
- * toClass is non-primitive.</p>
- *
- * <p>Specifically, this method tests whether the type represented by the
- * specified <code>Class</code> parameter can be converted to the type
- * represented by this <code>Class</code> object via an identity conversion
- * widening primitive or widening reference conversion. See
- * <em><a href="http://java.sun.com/docs/books/jls/";>The Java Language
Specification</a></em>,
- * sections 5.1.1, 5.1.2 and 5.1.4 for details.</p>
+ * <p>Checks if one <code>Class</code> can be assigned to a variable of
another <code>Class</code>.</p>
+ * <p/>
+ * <p>Unlike the [EMAIL PROTECTED] Class#isAssignableFrom(Class)} method,
this method takes into account widenings of primitive
+ * classes and <code>null</code>s.</p>
+ * <p/>
+ * <p>Primitive widenings allow an int to be assigned to a long, float or
double. This method returns the correct
+ * result for these cases.</p>
+ * <p/>
+ * <p><code>Null</code> may be assigned to any reference type. This method
will return <code>true</code> if
+ * <code>null</code> is passed in and the toClass is non-primitive.</p>
+ * <p/>
+ * <p>Specifically, this method tests whether the type represented by the
specified <code>Class</code> parameter can
+ * be converted to the type represented by this <code>Class</code> object
via an identity conversion widening
+ * primitive or widening reference conversion. See <em><a
href="http://java.sun.com/docs/books/jls/";>The Java
+ * Language Specification</a></em>, sections 5.1.1, 5.1.2 and 5.1.4 for
details.</p>
*
- * @param cls the Class to check, may be null
- * @param toClass the Class to try to assign into, returns false if null
+ * @param cls the Class to check, may be null
+ * @param toClass the Class to try to assign into, returns false if null
* @return <code>true</code> if assignment possible
*/
- public static boolean isAssignable(Class cls, Class toClass) {
- if (toClass == null) {
+ public static boolean isAssignable( Class cls, Class toClass )
+ {
+ if( toClass == null )
+ {
return false;
}
// have to check for null, as isAssignableFrom doesn't
- if (cls == null) {
- return !(toClass.isPrimitive());
+ if( cls == null )
+ {
+ return !( toClass.isPrimitive() );
}
- if (cls.equals(toClass)) {
+ if( cls.equals( toClass ) )
+ {
return true;
}
- if (cls.isPrimitive()) {
- if (toClass.isPrimitive() == false) {
+ if( cls.isPrimitive() )
+ {
+ if( toClass.isPrimitive() == false )
+ {
return false;
}
- if (Integer.TYPE.equals(cls)) {
- return Long.TYPE.equals(toClass)
- || Float.TYPE.equals(toClass)
- || Double.TYPE.equals(toClass);
- }
- if (Long.TYPE.equals(cls)) {
- return Float.TYPE.equals(toClass)
- || Double.TYPE.equals(toClass);
+ if( Integer.TYPE.equals( cls ) )
+ {
+ return Long.TYPE.equals( toClass )
+ || Float.TYPE.equals( toClass )
+ || Double.TYPE.equals( toClass );
+ }
+ if( Long.TYPE.equals( cls ) )
+ {
+ return Float.TYPE.equals( toClass )
+ || Double.TYPE.equals( toClass );
}
- if (Boolean.TYPE.equals(cls)) {
+ if( Boolean.TYPE.equals( cls ) )
+ {
return false;
}
- if (Double.TYPE.equals(cls)) {
+ if( Double.TYPE.equals( cls ) )
+ {
return false;
}
- if (Float.TYPE.equals(cls)) {
- return Double.TYPE.equals(toClass);
- }
- if (Character.TYPE.equals(cls)) {
- return Integer.TYPE.equals(toClass)
- || Long.TYPE.equals(toClass)
- || Float.TYPE.equals(toClass)
- || Double.TYPE.equals(toClass);
- }
- if (Short.TYPE.equals(cls)) {
- return Integer.TYPE.equals(toClass)
- || Long.TYPE.equals(toClass)
- || Float.TYPE.equals(toClass)
- || Double.TYPE.equals(toClass);
- }
- if (Byte.TYPE.equals(cls)) {
- return Short.TYPE.equals(toClass)
- || Integer.TYPE.equals(toClass)
- || Long.TYPE.equals(toClass)
- || Float.TYPE.equals(toClass)
- || Double.TYPE.equals(toClass);
+ if( Float.TYPE.equals( cls ) )
+ {
+ return Double.TYPE.equals( toClass );
+ }
+ if( Character.TYPE.equals( cls ) )
+ {
+ return Integer.TYPE.equals( toClass )
+ || Long.TYPE.equals( toClass )
+ || Float.TYPE.equals( toClass )
+ || Double.TYPE.equals( toClass );
+ }
+ if( Short.TYPE.equals( cls ) )
+ {
+ return Integer.TYPE.equals( toClass )
+ || Long.TYPE.equals( toClass )
+ || Float.TYPE.equals( toClass )
+ || Double.TYPE.equals( toClass );
+ }
+ if( Byte.TYPE.equals( cls ) )
+ {
+ return Short.TYPE.equals( toClass )
+ || Integer.TYPE.equals( toClass )
+ || Long.TYPE.equals( toClass )
+ || Float.TYPE.equals( toClass )
+ || Double.TYPE.equals( toClass );
}
// should never get here
return false;
}
- return toClass.isAssignableFrom(cls);
+ return toClass.isAssignableFrom( cls );
}
-
+
/**
- * <p>Converts the specified primitive Class object to its corresponding
- * wrapper Class object.</p>
- *
- * <p>NOTE: From v2.2, this method handles <code>Void.TYPE</code>,
- * returning <code>Void.TYPE</code>.</p>
- *
- * @param cls the class to convert, may be null
- * @return the wrapper class for <code>cls</code> or <code>cls</code> if
- * <code>cls</code> is not a primitive. <code>null</code> if null input.
+ * <p>Converts the specified primitive Class object to its corresponding
wrapper Class object.</p>
+ * <p/>
+ * <p>NOTE: From v2.2, this method handles <code>Void.TYPE</code>,
returning <code>Void.TYPE</code>.</p>
+ *
+ * @param cls the class to convert, may be null
+ * @return the wrapper class for <code>cls</code> or <code>cls</code> if
<code>cls</code> is not a primitive.
+ * <code>null</code> if null input.
* @since 2.1
*/
- public static Class primitiveToWrapper(Class cls) {
+ public static Class primitiveToWrapper( Class cls )
+ {
Class convertedClass = cls;
- if (cls != null && cls.isPrimitive()) {
- convertedClass = (Class) primitiveWrapperMap.get(cls);
- }
+ if( cls != null && cls.isPrimitive() )
+ {
+ convertedClass = ( Class ) primitiveWrapperMap.get( cls );
+ }
return convertedClass;
}
/**
- * <p>Converts the specified array of primitive Class objects to an array
of
- * its corresponding wrapper Class objects.</p>
+ * <p>Converts the specified array of primitive Class objects to an array
of its corresponding wrapper Class
+ * objects.</p>
*
- * @param classes the class array to convert, may be null or empty
- * @return an array which contains for each given class, the wrapper class
or
- * the original class if class is not a primitive. <code>null</code> if
null input.
- * Empty array if an empty array passed in.
+ * @param classes the class array to convert, may be null or empty
+ * @return an array which contains for each given class, the wrapper class
or the original class if class is not a
+ * primitive. <code>null</code> if null input. Empty array if an
empty array passed in.
* @since 2.1
*/
- public static Class[] primitivesToWrappers(Class[] classes) {
- if (classes == null) {
+ public static Class[] primitivesToWrappers( Class[] classes )
+ {
+ if( classes == null )
+ {
return null;
}
-
- if (classes.length == 0) {
+ if( classes.length == 0 )
+ {
return classes;
}
-
Class[] convertedClasses = new Class[classes.length];
- for (int i=0; i < classes.length; i++) {
+ for( int i = 0; i < classes.length; i++ )
+ {
convertedClasses[i] = primitiveToWrapper( classes[i] );
}
return convertedClasses;
@@ -489,18 +551,120 @@
// Inner class
// ----------------------------------------------------------------------
+
/**
* <p>Is the specified class an inner class or static nested class.</p>
- *
- * @param cls the class to check, may be null
- * @return <code>true</code> if the class is an inner or static nested
class,
- * false if not or <code>null</code>
+ *
+ * @param cls the class to check, may be null
+ * @return <code>true</code> if the class is an inner or static nested
class, false if not or <code>null</code>
*/
- public static boolean isInnerClass(Class cls) {
- if (cls == null) {
+ public static boolean isInnerClass( Class cls )
+ {
+ if( cls == null )
+ {
return false;
}
- return cls.getName().indexOf(INNER_CLASS_SEPARATOR_CHAR) >= 0;
+ return cls.getName().indexOf( INNER_CLASS_SEPARATOR_CHAR ) >= 0;
}
+ /**
+ * Returns the class represented by <code>className</code> using the
<code>classLoader</code>. This implementation
+ * supports names like "<code>java.lang.String[]</code>" as well as
"<code>[Ljava.lang.String;</code>".
+ *
+ * @param classLoader the class loader to use to load the class
+ * @param className the class name
+ * @param initialize whether the class must be initialized
+ * @return the class represented by <code>className</code> using the
<code>classLoader</code>
+ * @throws ClassNotFoundException if the class is not found
+ */
+ public static Class getClass( ClassLoader classLoader, String className,
boolean initialize )
+ throws ClassNotFoundException
+ {
+ Class clazz;
+ if( abbreviationMap.containsKey( className ) )
+ {
+ clazz = Class.forName( "[" + abbreviationMap.get( className ),
initialize, classLoader ).getComponentType();
+ }
+ else
+ {
+ clazz = Class.forName( toProperClassName( className ), initialize,
classLoader );
+ }
+ return clazz;
+ }
+
+ /**
+ * Returns the (initialized) class represented by <code>className</code>
using the <code>classLoader</code>. This
+ * implementation supports names like "<code>java.lang.String[]</code>" as
well as
+ * "<code>[Ljava.lang.String;</code>".
+ *
+ * @param classLoader the class loader to use to load the class
+ * @param className the class name
+ * @return the class represented by <code>className</code> using the
<code>classLoader</code>
+ * @throws ClassNotFoundException if the class is not found
+ */
+ public static Class getClass( ClassLoader classLoader, String className )
throws ClassNotFoundException
+ {
+ return getClass( classLoader, className, true );
+ }
+
+ /**
+ * Returns the (initialized )class represented by <code>className</code>
using the current thread's context class
+ * loader. This implementation supports names like
"<code>java.lang.String[]</code>" as well as
+ * "<code>[Ljava.lang.String;</code>".
+ *
+ * @param className the class name
+ * @return the class represented by <code>className</code> using the
current thread's context class loader
+ * @throws ClassNotFoundException if the class is not found
+ */
+ public static Class getClass( String className ) throws
ClassNotFoundException
+ {
+ return getClass( Thread.currentThread().getContextClassLoader() ==
null ? ClassUtils.class.getClassLoader() :
+ Thread.currentThread().getContextClassLoader(),
className, true );
+ }
+
+ /**
+ * Returns the class represented by <code>className</code> using the
current thread's context class loader. This
+ * implementation supports names like "<code>java.lang.String[]</code>" as
well as
+ * "<code>[Ljava.lang.String;</code>".
+ *
+ * @param className the class name
+ * @param initialize whether the class must be initialized
+ * @return the class represented by <code>className</code> using the
current thread's context class loader
+ * @throws ClassNotFoundException if the class is not found
+ */
+ public static Class getClass( String className, boolean initialize )
throws ClassNotFoundException
+ {
+ return getClass( Thread.currentThread().getContextClassLoader() ==
null ? ClassUtils.class.getClassLoader() :
+ Thread.currentThread().getContextClassLoader(),
className, initialize );
+ }
+
+ private static String toProperClassName( String className )
+ {
+ className = StringUtils.deleteWhitespace( className );
+ if( className == null )
+ {
+ throw new NullArgumentException( "className" );
+ }
+ else if( className.endsWith( "[]" ) )
+ {
+ final StringBuffer classNameBuffer = new StringBuffer();
+ while( className.endsWith( "[]" ) )
+ {
+ className = className.substring( 0, className.length() - 2 );
+ classNameBuffer.append( "[" );
+ }
+ final String abbreviation = ( String ) abbreviationMap.get(
className );
+ if( abbreviation != null )
+ {
+ classNameBuffer.append( abbreviation );
+ }
+ else
+ {
+ classNameBuffer.append( "L" ).append( className ).append( ";"
);
+ }
+ className = classNameBuffer.toString();
+
+ }
+ return className;
+ }
}
Modified:
jakarta/commons/proper/lang/trunk/src/test/org/apache/commons/lang/ClassUtilsTest.java
URL:
http://svn.apache.org/viewcvs/jakarta/commons/proper/lang/trunk/src/test/org/apache/commons/lang/ClassUtilsTest.java?rev=345284&r1=345283&r2=345284&view=diff
==============================================================================
---
jakarta/commons/proper/lang/trunk/src/test/org/apache/commons/lang/ClassUtilsTest.java
(original)
+++
jakarta/commons/proper/lang/trunk/src/test/org/apache/commons/lang/ClassUtilsTest.java
Thu Nov 17 08:51:02 2005
@@ -392,6 +392,110 @@
assertNotSame("unmodified", noPrimitives,
ClassUtils.primitivesToWrappers(noPrimitives));
}
+ public void testGetClassClassNotFound() throws Exception {
+ assertGetClassThrowsClassNotFound( "bool" );
+ assertGetClassThrowsClassNotFound( "bool[]" );
+ assertGetClassThrowsClassNotFound( "integer[]" );
+ }
+
+ public void testGetClassInvalidArguments() throws Exception {
+ assertGetClassThrowsIllegalArgument( null );
+ assertGetClassThrowsClassNotFound( "[][][]" );
+ assertGetClassThrowsClassNotFound( "[[]" );
+ assertGetClassThrowsClassNotFound( "[" );
+ assertGetClassThrowsClassNotFound( "java.lang.String][" );
+ assertGetClassThrowsClassNotFound( ".hello.world" );
+ assertGetClassThrowsClassNotFound( "hello..world" );
+ }
+
+ public void testWithInterleavingWhitespace() throws ClassNotFoundException
{
+ assertEquals( int[].class, ClassUtils.getClass( " int [ ] " ) );
+ assertEquals( long[].class, ClassUtils.getClass( "\rlong\t[\n]\r" ) );
+ assertEquals( short[].class, ClassUtils.getClass( "\tshort
\t\t[]" ) );
+ assertEquals( byte[].class, ClassUtils.getClass( "byte[\t\t\n\r] " )
);
+ }
+
+ public void testGetClassByNormalNameArrays() throws ClassNotFoundException
{
+ assertEquals( int[].class, ClassUtils.getClass( "int[]" ) );
+ assertEquals( long[].class, ClassUtils.getClass( "long[]" ) );
+ assertEquals( short[].class, ClassUtils.getClass( "short[]" ) );
+ assertEquals( byte[].class, ClassUtils.getClass( "byte[]" ) );
+ assertEquals( char[].class, ClassUtils.getClass( "char[]" ) );
+ assertEquals( float[].class, ClassUtils.getClass( "float[]" ) );
+ assertEquals( double[].class, ClassUtils.getClass( "double[]" ) );
+ assertEquals( boolean[].class, ClassUtils.getClass( "boolean[]" ) );
+ assertEquals( String[].class, ClassUtils.getClass(
"java.lang.String[]" ) );
+ }
+
+ public void testGetClassByNormalNameArrays2D() throws
ClassNotFoundException {
+ assertEquals( int[][].class, ClassUtils.getClass( "int[][]" ) );
+ assertEquals( long[][].class, ClassUtils.getClass( "long[][]" ) );
+ assertEquals( short[][].class, ClassUtils.getClass( "short[][]" ) );
+ assertEquals( byte[][].class, ClassUtils.getClass( "byte[][]" ) );
+ assertEquals( char[][].class, ClassUtils.getClass( "char[][]" ) );
+ assertEquals( float[][].class, ClassUtils.getClass( "float[][]" ) );
+ assertEquals( double[][].class, ClassUtils.getClass( "double[][]" ) );
+ assertEquals( boolean[][].class, ClassUtils.getClass( "boolean[][]" )
);
+ assertEquals( String[][].class, ClassUtils.getClass(
"java.lang.String[][]" ) );
+ }
+
+ public void testGetClassWithArrayClasses2D() throws Exception {
+ assertGetClassReturnsClass( String[][].class );
+ assertGetClassReturnsClass( int[][].class );
+ assertGetClassReturnsClass( long[][].class );
+ assertGetClassReturnsClass( short[][].class );
+ assertGetClassReturnsClass( byte[][].class );
+ assertGetClassReturnsClass( char[][].class );
+ assertGetClassReturnsClass( float[][].class );
+ assertGetClassReturnsClass( double[][].class );
+ assertGetClassReturnsClass( boolean[][].class );
+ }
+
+ public void testGetClassWithArrayClasses() throws Exception {
+ assertGetClassReturnsClass( String[].class );
+ assertGetClassReturnsClass( int[].class );
+ assertGetClassReturnsClass( long[].class );
+ assertGetClassReturnsClass( short[].class );
+ assertGetClassReturnsClass( byte[].class );
+ assertGetClassReturnsClass( char[].class );
+ assertGetClassReturnsClass( float[].class );
+ assertGetClassReturnsClass( double[].class );
+ assertGetClassReturnsClass( boolean[].class );
+ }
+
+ public void testGetClassRawPrimitives() throws ClassNotFoundException {
+ assertEquals( int.class, ClassUtils.getClass( "int" ) );
+ assertEquals( long.class, ClassUtils.getClass( "long" ) );
+ assertEquals( short.class, ClassUtils.getClass( "short" ) );
+ assertEquals( byte.class, ClassUtils.getClass( "byte" ) );
+ assertEquals( char.class, ClassUtils.getClass( "char" ) );
+ assertEquals( float.class, ClassUtils.getClass( "float" ) );
+ assertEquals( double.class, ClassUtils.getClass( "double" ) );
+ assertEquals( boolean.class, ClassUtils.getClass( "boolean" ) );
+ }
+
+ private void assertGetClassReturnsClass( Class c ) throws Exception {
+ assertEquals( c, ClassUtils.getClass( c.getName() ) );
+ }
+
+ private void assertGetClassThrowsException( String className, Class
exceptionType ) throws Exception {
+ try {
+ ClassUtils.getClass( className );
+ fail( "ClassUtils.getClass() should fail with an exception of type
" + exceptionType.getName() + " when given class name \"" + className + "\"." );
+ }
+ catch( Exception e ) {
+ assertTrue( exceptionType.isAssignableFrom( e.getClass() ) );
+ }
+ }
+
+ private void assertGetClassThrowsIllegalArgument( String className )
throws Exception {
+ assertGetClassThrowsException( className,
IllegalArgumentException.class );
+ }
+
+ private void assertGetClassThrowsClassNotFound( String className ) throws
Exception {
+ assertGetClassThrowsException( className, ClassNotFoundException.class
);
+ }
+
/**
* Creates a new instance of URLClassLoader with the system class loader's
URLs and a <code>null</code> parent
* class loader.
---------------------------------------------------------------------
To unsubscribe, e-mail: [EMAIL PROTECTED]
For additional commands, e-mail: [EMAIL PROTECTED]
