ClassLoaderUtil.getClass(*) now uses generics

Author: garydgregory

src/changes/changes.xml

@@ -139,6 +139,10 @@ The <action> type attribute can be add,update,fix,remove.
       <action dev="ggregory" type="fix" due-to="Gary Gregory">org.apache.commons.jxpath.ri.JXPathContextReferenceImpl.iteratePointers(String, Expression) now uses generics.</action>
       <action dev="ggregory" type="fix" due-to="Gary Gregory">org.apache.commons.jxpath.CompiledExpression.iteratePointers(JXPathContext) now uses generics.</action>
       <action dev="ggregory" type="fix" due-to="Gary Gregory">org.apache.commons.jxpath.JXPathCompiledExpression.iteratePointers(JXPathContext) now uses generics.</action>
+      <action dev="ggregory" type="fix" due-to="Gary Gregory">org.apache.commons.jxpath.util.ClassLoaderUtil.getClass(ClassLoader, String) now uses generics.</action>
+      <action dev="ggregory" type="fix" due-to="Gary Gregory">org.apache.commons.jxpath.util.ClassLoaderUtil.getClass(ClassLoader, String, boolean) now uses generics.</action>
+      <action dev="ggregory" type="fix" due-to="Gary Gregory">org.apache.commons.jxpath.util.ClassLoaderUtil.getClass(String) now uses generics.</action>
+      <action dev="ggregory" type="fix" due-to="Gary Gregory">org.apache.commons.jxpath.util.ClassLoaderUtil.getClass(String, boolean) now uses generics.</action>
       <!-- ADD -->
       <action issue="JXPATH-123" dev="mbenson" type="add">
         XPath function "ends-with" is not implemented (although "starts-with" is).

src/main/java/org/apache/commons/jxpath/JXPathContextFactory.java

@@ -156,8 +156,7 @@ private static String findFactory(final String property, final String defaultFac
     public static JXPathContextFactory newInstance() {
         JXPathContextFactory factoryImpl;
         try {
-            final Class clazz = ClassLoaderUtil.getClass(FACTORY_IMPL_NAME, true);
-            factoryImpl = (JXPathContextFactory) clazz.getConstructor().newInstance();
+            factoryImpl = ClassLoaderUtil.<JXPathContextFactory>getClass(FACTORY_IMPL_NAME, true).getConstructor().newInstance();
         } catch (final ReflectiveOperationException ie) {
             throw new JXPathContextFactoryConfigurationError(ie);
         }

src/main/java/org/apache/commons/jxpath/JXPathIntrospector.java

@@ -166,8 +166,7 @@ private static Object instantiate(final Class sibling, final String className) t
             }
         }
         // Now try the ClassLoaderUtil.
-        final Class cls = ClassLoaderUtil.getClass(className);
-        return cls.newInstance();
+        return ClassLoaderUtil.getClass(className).newInstance();
     }
 
     /**

src/main/java/org/apache/commons/jxpath/PackageFunctions.java

@@ -144,7 +144,7 @@ public Function getFunction(final String namespace, final String name, Object[]
         }
         final String className = fullName.substring(0, inx);
         final String methodName = fullName.substring(inx + 1);
-        Class functionClass;
+        Class<?> functionClass;
         try {
             functionClass = ClassLoaderUtil.getClass(className, true);
         } catch (final ClassNotFoundException ex) {

src/main/java/org/apache/commons/jxpath/ri/JXPathContextReferenceImpl.java

@@ -125,8 +125,7 @@ public static Object allocateConditionally(final String className, final String
             } catch (final ClassNotFoundException ex) {
                 return null;
             }
-            final Class<NodePointerFactory> cls = ClassLoaderUtil.getClass(className, true);
-            return cls.getConstructor().newInstance();
+            return ClassLoaderUtil.getClass(className, true).getConstructor().newInstance();
         } catch (final Exception ex) {
             throw new JXPathException("Cannot allocate " + className, ex);
         }

src/main/java/org/apache/commons/jxpath/util/ClassLoaderUtil.java

@@ -62,12 +62,13 @@ private static void addAbbreviation(final String primitive, final String abbrevi
      * Returns the (initialized) class represented by {@code className} using the {@code classLoader}. This implementation supports names like
      * "{@code java.lang.String[]}" as well as "{@code [Ljava.lang.String;}".
      *
+     * @param <T> The expected class type.
      * @param classLoader the class loader to use to load the class
      * @param className   the class name
      * @return the class represented by {@code className} using the {@code classLoader}
      * @throws ClassNotFoundException if the class is not found
      */
-    public static Class getClass(final ClassLoader classLoader, final String className) throws ClassNotFoundException {
+    public static <T> Class<T> getClass(final ClassLoader classLoader, final String className) throws ClassNotFoundException {
         return getClass(classLoader, className, true);
     }
 
@@ -76,19 +77,21 @@ public static Class getClass(final ClassLoader classLoader, final String classNa
      * Returns the class represented by {@code className} using the {@code classLoader}. This implementation supports names like "{@code java.lang.String[]}" as
      * well as "{@code [Ljava.lang.String;}".
      *
+     * @param <T> The expected class type.
      * @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} using the {@code classLoader}
      * @throws ClassNotFoundException if the class is not found
      */
-    public static Class getClass(final ClassLoader classLoader, final String className, final boolean initialize) throws ClassNotFoundException {
-        Class clazz;
+    @SuppressWarnings("unchecked") // assume the call site knows what it's doing.
+    public static <T> Class<T> getClass(final ClassLoader classLoader, final String className, final boolean initialize) throws ClassNotFoundException {
+        Class<T> clazz;
         if (abbreviationMap.containsKey(className)) {
             final String clsName = "[" + abbreviationMap.get(className);
-            clazz = Class.forName(clsName, initialize, classLoader).getComponentType();
+            clazz = (Class<T>) Class.forName(clsName, initialize, classLoader).getComponentType();
         } else {
-            clazz = Class.forName(toCanonicalName(className), initialize, classLoader);
+            clazz = (Class<T>) Class.forName(toCanonicalName(className), initialize, classLoader);
         }
         return clazz;
     }
@@ -97,24 +100,26 @@ public static Class getClass(final ClassLoader classLoader, final String classNa
      * Returns the (initialized) class represented by {@code className} using the current thread's context class loader. This implementation supports names like
      * "{@code java.lang.String[]}" as well as "{@code [Ljava.lang.String;}".
      *
+     * @param <T> The expected class type.
      * @param className the class name
      * @return the class represented by {@code className} using the current thread's context class loader
      * @throws ClassNotFoundException if the class is not found
      */
-    public static Class getClass(final String className) throws ClassNotFoundException {
+    public static <T> Class<T> getClass(final String className) throws ClassNotFoundException {
         return getClass(className, true);
     }
 
     /**
      * Returns the class represented by {@code className} using the current thread's context class loader. This implementation supports names like
      * "{@code java.lang.String[]}" as well as "{@code [Ljava.lang.String;}".
      *
+     * @param <T> The expected class type.
      * @param className  the class name
      * @param initialize whether the class must be initialized
      * @return the class represented by {@code className} using the current thread's context class loader
      * @throws ClassNotFoundException if the class is not found
      */
-    public static Class getClass(final String className, final boolean initialize) throws ClassNotFoundException {
+    public static <T> Class<T> getClass(final String className, final boolean initialize) throws ClassNotFoundException {
         final ClassLoader contextCL = Thread.currentThread().getContextClassLoader();
         final ClassLoader currentCL = ClassLoaderUtil.class.getClassLoader();
         if (contextCL != null) {

src/main/java/org/apache/commons/jxpath/xml/DocumentContainer.java

@@ -60,8 +60,7 @@ private static XMLParser getParser(final String model) {
                 throw new JXPathException("Unsupported XML model: " + model);
             }
             try {
-                final Class<XMLParser> clazz = ClassLoaderUtil.getClass(className, true);
-                return clazz.getConstructor().newInstance();
+                return ClassLoaderUtil.<XMLParser>getClass(className, true).getConstructor().newInstance();
             } catch (final Exception ex) {
                 throw new JXPathException("Cannot allocate XMLParser: " + className, ex);
             }