You are viewing a plain text version of this content. The canonical link for it is here.
Posted to dev@commons.apache.org by jc...@apache.org on 2005/11/17 17:51:10 UTC
svn commit: r345284 - in /jakarta/commons/proper/lang/trunk/src:
java/org/apache/commons/lang/ClassUtils.java
test/org/apache/commons/lang/ClassUtilsTest.java
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>'.' == {@value}</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>'$' == {@value}</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 {@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 compatible with a set of method
+ * parameter types (the second parameter).</p>
+ * <p/>
+ * <p>Unlike the {@link 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 {@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 compatible 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
- * <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 {@link 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 {@link 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: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org
RE: svn commit: r345284 - in /jakarta/commons/proper/lang/trunk/src: java/org/apache/commons/lang/ClassUtils.java test/org/apache/commons/lang/ClassUtilsTest.java
Posted by James Carman <ja...@carmanconsulting.com>.
Yeah, I believe it was an accident. I apologize. By the way, I changed my
settings in IDEA to try to match Commons Lang's style (so now if I do it on
accident, it won't be that big of a deal). Here's what the file contains:
<?xml version="1.0" encoding="UTF-8"?>
<code_scheme name="Commons Collections">
<option name="ELSE_ON_NEW_LINE" value="true" />
<option name="WHILE_ON_NEW_LINE" value="true" />
<option name="CATCH_ON_NEW_LINE" value="true" />
<option name="FINALLY_ON_NEW_LINE" value="true" />
<option name="ALIGN_MULTILINE_PARAMETERS_IN_CALLS" value="true" />
<option name="ALIGN_MULTILINE_BINARY_OPERATION" value="true" />
<option name="ALIGN_MULTILINE_ASSIGNMENT" value="true" />
<option name="ALIGN_MULTILINE_TERNARY_OPERATION" value="true" />
<option name="ALIGN_MULTILINE_THROWS_LIST" value="true" />
<option name="ALIGN_MULTILINE_EXTENDS_LIST" value="true" />
<option name="ALIGN_MULTILINE_PARENTHESIZED_EXPRESSION" value="true" />
<option name="KEEP_BLANK_LINES_IN_DECLARATIONS" value="0" />
<option name="KEEP_BLANK_LINES_IN_CODE" value="0" />
<option name="SPACE_WITHIN_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_METHOD_CALL_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_METHOD_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_IF_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_WHILE_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_FOR_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_CATCH_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_SWITCH_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_SYNCHRONIZED_PARENTHESES" value="true" />
<option name="SPACE_WITHIN_CAST_PARENTHESES" value="true" />
<option name="SPACE_BEFORE_IF_PARENTHESES" value="false" />
<option name="SPACE_BEFORE_WHILE_PARENTHESES" value="false" />
<option name="SPACE_BEFORE_FOR_PARENTHESES" value="false" />
<option name="SPACE_BEFORE_CATCH_PARENTHESES" value="false" />
<option name="SPACE_BEFORE_SWITCH_PARENTHESES" value="false" />
<option name="SPACE_BEFORE_SYNCHRONIZED_PARENTHESES" value="false" />
<option name="CLASS_COUNT_TO_USE_IMPORT_ON_DEMAND" value="99999999" />
<option name="PACKAGES_TO_USE_IMPORT_ON_DEMAND">
<value />
</option>
<option name="CALL_PARAMETERS_WRAP" value="1" />
<option name="METHOD_PARAMETERS_WRAP" value="1" />
<option name="EXTENDS_LIST_WRAP" value="1" />
<option name="THROWS_LIST_WRAP" value="1" />
<option name="EXTENDS_KEYWORD_WRAP" value="1" />
<option name="THROWS_KEYWORD_WRAP" value="1" />
<option name="METHOD_CALL_CHAIN_WRAP" value="1" />
<option name="BINARY_OPERATION_WRAP" value="1" />
<option name="TERNARY_OPERATION_WRAP" value="1" />
<option name="FOR_STATEMENT_WRAP" value="1" />
<option name="ARRAY_INITIALIZER_WRAP" value="1" />
<option name="ASSIGNMENT_WRAP" value="1" />
<option name="WRAP_COMMENTS" value="true" />
<option name="ASSERT_STATEMENT_WRAP" value="1" />
<option name="IF_BRACE_FORCE" value="3" />
<option name="DOWHILE_BRACE_FORCE" value="3" />
<option name="WHILE_BRACE_FORCE" value="3" />
<option name="FOR_BRACE_FORCE" value="3" />
<option name="PARAMETER_ANNOTATION_WRAP" value="1" />
<option name="VARIABLE_ANNOTATION_WRAP" value="1" />
<option name="ENUM_CONSTANTS_WRAP" value="1" />
</code_scheme>
-----Original Message-----
From: Martin van den Bemt [mailto:mllist@mvdb.net]
Sent: Sunday, December 18, 2005 5:32 PM
To: Jakarta Commons Developers List
Subject: Re: svn commit: r345284 - in
/jakarta/commons/proper/lang/trunk/src:
java/org/apache/commons/lang/ClassUtils.java
test/org/apache/commons/lang/ClassUtilsTest.java
I cannot help you with that, but just want to give a tip : when changing
code, never reformat anything. Just follow the code style currently used in
the java file (also since almost every project uses a different coding
style). If you really want to reformat code, just do that in a seperate
commit. This way it is easier to track the real changes.
Mvgr,
Martin
James Carman wrote:
> Sorry. Does anyone have a code style file for intellij IDEA for Commons
> Lang?
---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org
Re: svn commit: r345284 - in /jakarta/commons/proper/lang/trunk/src:
java/org/apache/commons/lang/ClassUtils.java test/org/apache/commons/lang/ClassUtilsTest.java
Posted by Martin van den Bemt <ml...@mvdb.net>.
I cannot help you with that, but just want to give a tip : when changing code, never reformat anything. Just follow the code style currently used in the java file (also since almost every project uses a different coding style). If you really want to reformat code, just do that in a seperate commit. This way it is easier to track the real changes.
Mvgr,
Martin
James Carman wrote:
> Sorry. Does anyone have a code style file for intellij IDEA for Commons
> Lang?
---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org
RE: svn commit: r345284 - in /jakarta/commons/proper/lang/trunk/src: java/org/apache/commons/lang/ClassUtils.java test/org/apache/commons/lang/ClassUtilsTest.java
Posted by James Carman <ja...@carmanconsulting.com>.
Sorry. Does anyone have a code style file for intellij IDEA for Commons
Lang?
-----Original Message-----
From: Stephen Colebourne [mailto:scolebourne@btopenworld.com]
Sent: Sunday, December 18, 2005 3:55 PM
To: Jakarta Commons Developers List
Subject: Re: svn commit: r345284 - in
/jakarta/commons/proper/lang/trunk/src:
java/org/apache/commons/lang/ClassUtils.java
test/org/apache/commons/lang/ClassUtilsTest.java
-1
This change completely reformatted the class. This is not acceptable in
itself, but also breaks the lang style guidelines. Sorry James.
Stephen
jcarman@apache.org wrote:
> 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/ClassUtil
s.java
>
jakarta/commons/proper/lang/trunk/src/test/org/apache/commons/lang/ClassUtil
sTest.java
>
> Modified:
jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtil
s.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=dif
f
>
============================================================================
==
> ---
jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtil
s.java (original)
> +++
jakarta/commons/proper/lang/trunk/src/java/org/apache/commons/lang/ClassUtil
s.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>'.' ==
{@value}</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>'$' ==
{@value}</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 {@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 compatible with a set of method
> + * parameter types (the second parameter).</p>
> + * <p/>
> + * <p>Unlike the {@link 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 {@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 compatible 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
> - * <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 {@link 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 {@link 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/ClassUtil
sTest.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/ClassUtil
sTest.java (original)
> +++
jakarta/commons/proper/lang/trunk/src/test/org/apache/commons/lang/ClassUtil
sTest.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: commons-dev-unsubscribe@jakarta.apache.org
> For additional commands, e-mail: commons-dev-help@jakarta.apache.org
>
>
---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org
Re: svn commit: r345284 - in /jakarta/commons/proper/lang/trunk/src:
java/org/apache/commons/lang/ClassUtils.java test/org/apache/commons/lang/ClassUtilsTest.java
Posted by Stephen Colebourne <sc...@btopenworld.com>.
-1
This change completely reformatted the class. This is not acceptable in
itself, but also breaks the lang style guidelines. Sorry James.
Stephen
jcarman@apache.org wrote:
> 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>'.' == {@value}</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>'$' == {@value}</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 {@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 compatible with a set of method
> + * parameter types (the second parameter).</p>
> + * <p/>
> + * <p>Unlike the {@link 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 {@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 compatible 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
> - * <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 {@link 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 {@link 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: commons-dev-unsubscribe@jakarta.apache.org
> For additional commands, e-mail: commons-dev-help@jakarta.apache.org
>
>
---------------------------------------------------------------------
To unsubscribe, e-mail: commons-dev-unsubscribe@jakarta.apache.org
For additional commands, e-mail: commons-dev-help@jakarta.apache.org