IO-140 JDK 1.5 changes: Use generics

git-svn-id: https://svn.apache.org/repos/asf/commons/proper/io/trunk@619103 13f79535-47bb-0310-9956-ffa450edef68

Author: Niall Pemberton

src/java/org/apache/commons/io/FileCleaningTracker.java

@@ -48,7 +48,7 @@ public class FileCleaningTracker {
     /**
      * Collection of <code>Tracker</code> instances in existence.
      */
-    final Collection /* Tracker */ trackers = new Vector();  // synchronized
+    final Collection<Tracker> trackers = new Vector<Tracker>();  // synchronized
     /**
      * Whether to terminate the thread when the tracking is complete.
      */

src/java/org/apache/commons/io/FileSystemUtils.java

@@ -320,14 +320,14 @@ long freeSpaceUnix(String path, boolean kb, boolean posix) throws IOException {
             (flags.length() > 1 ? new String[] {"df", flags, path} : new String[] {"df", path});
 
         // perform the command, asking for up to 3 lines (header, interesting, overflow)
-        List lines = performCommand(cmdAttribs, 3);
+        List<String> lines = performCommand(cmdAttribs, 3);
         if (lines.size() < 2) {
             // unknown problem, throw exception
             throw new IOException(
                     "Command line 'df' did not return info as expected " +
                     "for path '" + path + "'- response was " + lines);
         }
-        String line2 = (String) lines.get(1); // the line we're interested in
+        String line2 = lines.get(1); // the line we're interested in
 
         // Now, we tokenize the string. The fourth element is what we want.
         StringTokenizer tok = new StringTokenizer(line2, " ");
@@ -385,7 +385,7 @@ long parseBytes(String freeSpace, String path) throws IOException {
      * @return the parsed data
      * @throws IOException if an error occurs
      */
-    List performCommand(String[] cmdAttribs, int max) throws IOException {
+    List<String> performCommand(String[] cmdAttribs, int max) throws IOException {
         // this method does what it can to avoid the 'Too many open files' error
         // based on trial and error and these links:
         // http://bugs.sun.com/bugdatabase/view_bug.do?bug_id=4784692
@@ -394,7 +394,7 @@ List performCommand(String[] cmdAttribs, int max) throws IOException {
         // however, its still not perfect as the JDK support is so poor
         // (see commond-exec or ant for a better multi-threaded multi-os solution)
 
-        List lines = new ArrayList(20);
+        List<String> lines = new ArrayList<String>(20);
         Process proc = null;
         InputStream in = null;
         OutputStream out = null;

src/java/org/apache/commons/io/FileUtils.java

@@ -235,8 +235,8 @@ public static void touch(File file) throws IOException {
      * @param files  a Collection containing java.io.File instances
      * @return an array of java.io.File
      */
-    public static File[] convertFileCollectionToFileArray(Collection files) {
-         return (File[]) files.toArray(new File[files.size()]);
+    public static File[] convertFileCollectionToFileArray(Collection<File> files) {
+         return files.toArray(new File[files.size()]);
     }
 
     //-----------------------------------------------------------------------
@@ -248,7 +248,7 @@ public static File[] convertFileCollectionToFileArray(Collection files) {
      * @param directory the directory to search in.
      * @param filter the filter to apply to files and directories.
      */
-    private static void innerListFiles(Collection files, File directory,
+    private static void innerListFiles(Collection<File> files, File directory,
             IOFileFilter filter) {
         File[] found = directory.listFiles((FileFilter) filter);
         if (found != null) {
@@ -287,7 +287,7 @@ private static void innerListFiles(Collection files, File directory,
      * @see org.apache.commons.io.filefilter.FileFilterUtils
      * @see org.apache.commons.io.filefilter.NameFileFilter
      */
-    public static Collection listFiles(
+    public static Collection<File> listFiles(
             File directory, IOFileFilter fileFilter, IOFileFilter dirFilter) {
         if (!directory.isDirectory()) {
             throw new IllegalArgumentException(
@@ -311,7 +311,7 @@ public static Collection listFiles(
         }
 
         //Find files
-        Collection files = new java.util.LinkedList();
+        Collection<File> files = new java.util.LinkedList<File>();
         innerListFiles(files, directory,
             FileFilterUtils.orFileFilter(effFileFilter, effDirFilter));
         return files;
@@ -873,11 +873,11 @@ public static void copyDirectory(File srcDir, File destDir,
         }
 
         // Cater for destination being directory within the source directory (see IO-141)
-        List exclusionList = null;
+        List<String> exclusionList = null;
         if (destDir.getCanonicalPath().startsWith(srcDir.getCanonicalPath())) {
             File[] srcFiles = filter == null ? srcDir.listFiles() : srcDir.listFiles(filter);
             if (srcFiles != null && srcFiles.length > 0) {
-                exclusionList = new ArrayList(srcFiles.length);
+                exclusionList = new ArrayList<String>(srcFiles.length);
                 for (int i = 0; i < srcFiles.length; i++) {
                     File copiedFile = new File(destDir, srcFiles[i].getName());
                     exclusionList.add(copiedFile.getCanonicalPath());
@@ -899,7 +899,7 @@ public static void copyDirectory(File srcDir, File destDir,
      * @since Commons IO 1.1
      */
     private static void doCopyDirectory(File srcDir, File destDir, FileFilter filter,
-            boolean preserveFileDate, List exclusionList) throws IOException {
+            boolean preserveFileDate, List<String> exclusionList) throws IOException {
         if (destDir.exists()) {
             if (destDir.isDirectory() == false) {
                 throw new IOException("Destination '" + destDir + "' exists but is not a directory");

src/java/org/apache/commons/io/FilenameUtils.java

@@ -1152,12 +1152,12 @@ public static boolean wildcardMatch(String filename, String wildcardMatcher, IOC
         boolean anyChars = false;
         int textIdx = 0;
         int wcsIdx = 0;
-        Stack backtrack = new Stack();
+        Stack<int[]> backtrack = new Stack<int[]>();
 
         // loop around a backtrack stack, to handle complex * matching
         do {
             if (backtrack.size() > 0) {
-                int[] array = (int[]) backtrack.pop();
+                int[] array = backtrack.pop();
                 wcsIdx = array[0];
                 textIdx = array[1];
                 anyChars = true;
@@ -1232,7 +1232,7 @@ static String[] splitOnTokens(String text) {
         }
 
         char[] array = text.toCharArray();
-        ArrayList list = new ArrayList();
+        ArrayList<String> list = new ArrayList<String>();
         StringBuffer buffer = new StringBuffer();
         for (int i = 0; i < array.length; i++) {
             if (array[i] == '?' || array[i] == '*') {
@@ -1254,7 +1254,7 @@ static String[] splitOnTokens(String text) {
             list.add(buffer.toString());
         }
 
-        return (String[]) list.toArray( new String[ list.size() ] );
+        return list.toArray( new String[ list.size() ] );
     }
 
 }

src/java/org/apache/commons/io/IOUtils.java

@@ -496,9 +496,9 @@ public static List readLines(InputStream input, String encoding) throws IOExcept
      * @throws IOException if an I/O error occurs
      * @since Commons IO 1.1
      */
-    public static List readLines(Reader input) throws IOException {
+    public static List<String> readLines(Reader input) throws IOException {
         BufferedReader reader = new BufferedReader(input);
-        List list = new ArrayList();
+        List<String> list = new ArrayList<String>();
         String line = reader.readLine();
         while (line != null) {
             list.add(line);

src/java/org/apache/commons/io/LineIterator.java

@@ -50,7 +50,7 @@
  * @version $Id$
  * @since Commons IO 1.2
  */
-public class LineIterator implements Iterator {
+public class LineIterator implements Iterator<String> {
 
     /** The reader that is being read. */
     private final BufferedReader bufferedReader;
@@ -125,7 +125,7 @@ protected boolean isValidLine(String line) {
      * @return the next line from the input
      * @throws NoSuchElementException if there is no line to return
      */
-    public Object next() {
+    public String next() {
         return nextLine();
     }
 

src/java/org/apache/commons/io/comparator/DefaultFileComparator.java

@@ -44,25 +44,23 @@
  * @version $Revision$ $Date$
  * @since Commons IO 1.4
  */
-public class DefaultFileComparator implements Comparator, Serializable {
+public class DefaultFileComparator implements Comparator<File>, Serializable {
 
     /** Singleton default comparator instance */
-    public static final Comparator DEFAULT_COMPARATOR = new DefaultFileComparator();
+    public static final Comparator<File> DEFAULT_COMPARATOR = new DefaultFileComparator();
 
     /** Singleton reverse default comparator instance */
-    public static final Comparator DEFAULT_REVERSE = new ReverseComparator(DEFAULT_COMPARATOR);
+    public static final Comparator<File> DEFAULT_REVERSE = new ReverseComparator(DEFAULT_COMPARATOR);
 
     /**
      * Compare the two files using the {@link File#compareTo(File)} method.
      * 
-     * @param obj1 The first file to compare
-     * @param obj2 The second file to compare
+     * @param file1 The first file to compare
+     * @param file2 The second file to compare
      * @return the result of calling file1's
      * {@link File#compareTo(File)} with file2 as the parameter.
      */
-    public int compare(Object obj1, Object obj2) {
-        File file1 = (File)obj1;
-        File file2 = (File)obj2;
+    public int compare(File file1, File file2) {
         return file1.compareTo(file2);
     }
 }

src/java/org/apache/commons/io/comparator/ExtensionFileComparator.java

@@ -51,26 +51,26 @@
  * @version $Revision$ $Date$
  * @since Commons IO 1.4
  */
-public class ExtensionFileComparator implements Comparator, Serializable {
+public class ExtensionFileComparator implements Comparator<File>, Serializable {
 
     /** Case-sensitive extension comparator instance (see {@link IOCase#SENSITIVE}) */
-    public static final Comparator EXTENSION_COMPARATOR = new ExtensionFileComparator();
+    public static final Comparator<File> EXTENSION_COMPARATOR = new ExtensionFileComparator();
 
     /** Reverse case-sensitive extension comparator instance (see {@link IOCase#SENSITIVE}) */
-    public static final Comparator EXTENSION_REVERSE = new ReverseComparator(EXTENSION_COMPARATOR);
+    public static final Comparator<File> EXTENSION_REVERSE = new ReverseComparator(EXTENSION_COMPARATOR);
 
     /** Case-insensitive extension comparator instance (see {@link IOCase#INSENSITIVE}) */
-    public static final Comparator EXTENSION_INSENSITIVE_COMPARATOR = new ExtensionFileComparator(IOCase.INSENSITIVE);
+    public static final Comparator<File> EXTENSION_INSENSITIVE_COMPARATOR = new ExtensionFileComparator(IOCase.INSENSITIVE);
 
     /** Reverse case-insensitive extension comparator instance (see {@link IOCase#INSENSITIVE}) */
-    public static final Comparator EXTENSION_INSENSITIVE_REVERSE
+    public static final Comparator<File> EXTENSION_INSENSITIVE_REVERSE
                                                 = new ReverseComparator(EXTENSION_INSENSITIVE_COMPARATOR);
 
     /** System sensitive extension comparator instance (see {@link IOCase#SYSTEM}) */
-    public static final Comparator EXTENSION_SYSTEM_COMPARATOR = new ExtensionFileComparator(IOCase.SYSTEM);
+    public static final Comparator<File> EXTENSION_SYSTEM_COMPARATOR = new ExtensionFileComparator(IOCase.SYSTEM);
 
     /** Reverse system sensitive path comparator instance (see {@link IOCase#SYSTEM}) */
-    public static final Comparator EXTENSION_SYSTEM_REVERSE = new ReverseComparator(EXTENSION_SYSTEM_COMPARATOR);
+    public static final Comparator<File> EXTENSION_SYSTEM_REVERSE = new ReverseComparator(EXTENSION_SYSTEM_COMPARATOR);
 
     /** Whether the comparison is case sensitive. */
     private final IOCase caseSensitivity;
@@ -94,17 +94,15 @@ public ExtensionFileComparator(IOCase caseSensitivity) {
     /**
      * Compare the extensions of two files the specified case sensitivity.
      * 
-     * @param obj1 The first file to compare
-     * @param obj2 The second file to compare
+     * @param file1 The first file to compare
+     * @param file2 The second file to compare
      * @return a negative value if the first file's extension
      * is less than the second, zero if the extensions are the
      * same and a positive value if the first files extension
      * is greater than the second file.
      * 
      */
-    public int compare(Object obj1, Object obj2) {
-        File file1 = (File)obj1;
-        File file2 = (File)obj2;
+    public int compare(File file1, File file2) {
         String suffix1 = FilenameUtils.getExtension(file1.getName());
         String suffix2 = FilenameUtils.getExtension(file2.getName());
         return caseSensitivity.checkCompareTo(suffix1, suffix2);

src/java/org/apache/commons/io/comparator/LastModifiedFileComparator.java

@@ -45,28 +45,26 @@
  * @version $Revision$ $Date$
  * @since Commons IO 1.4
  */
-public class LastModifiedFileComparator implements Comparator, Serializable {
+public class LastModifiedFileComparator implements Comparator<File>, Serializable {
 
     /** Last modified comparator instance */
-    public static final Comparator LASTMODIFIED_COMPARATOR = new LastModifiedFileComparator();
+    public static final Comparator<File> LASTMODIFIED_COMPARATOR = new LastModifiedFileComparator();
 
     /** Reverse last modified comparator instance */
-    public static final Comparator LASTMODIFIED_REVERSE = new ReverseComparator(LASTMODIFIED_COMPARATOR);
+    public static final Comparator<File> LASTMODIFIED_REVERSE = new ReverseComparator(LASTMODIFIED_COMPARATOR);
 
     /**
      * Compare the last the last modified date/time of two files.
      * 
-     * @param obj1 The first file to compare
-     * @param obj2 The second file to compare
+     * @param file1 The first file to compare
+     * @param file2 The second file to compare
      * @return a negative value if the first file's lastmodified date/time
      * is less than the second, zero if the lastmodified date/time are the
      * same and a positive value if the first files lastmodified date/time
      * is greater than the second file.
      * 
      */
-    public int compare(Object obj1, Object obj2) {
-        File file1 = (File)obj1;
-        File file2 = (File)obj2;
+    public int compare(File file1, File file2) {
         long result = file1.lastModified() - file2.lastModified();
         if (result < 0) {
             return -1;

src/java/org/apache/commons/io/comparator/NameFileComparator.java

@@ -49,25 +49,25 @@
  * @version $Revision$ $Date$
  * @since Commons IO 1.4
  */
-public class NameFileComparator implements Comparator, Serializable {
+public class NameFileComparator implements Comparator<File>, Serializable {
 
     /** Case-sensitive name comparator instance (see {@link IOCase#SENSITIVE}) */
-    public static final Comparator NAME_COMPARATOR = new NameFileComparator();
+    public static final Comparator<File> NAME_COMPARATOR = new NameFileComparator();
 
     /** Reverse case-sensitive name comparator instance (see {@link IOCase#SENSITIVE}) */
-    public static final Comparator NAME_REVERSE = new ReverseComparator(NAME_COMPARATOR);
+    public static final Comparator<File> NAME_REVERSE = new ReverseComparator(NAME_COMPARATOR);
 
     /** Case-insensitive name comparator instance (see {@link IOCase#INSENSITIVE}) */
-    public static final Comparator NAME_INSENSITIVE_COMPARATOR = new NameFileComparator(IOCase.INSENSITIVE);
+    public static final Comparator<File> NAME_INSENSITIVE_COMPARATOR = new NameFileComparator(IOCase.INSENSITIVE);
 
     /** Reverse case-insensitive name comparator instance (see {@link IOCase#INSENSITIVE}) */
-    public static final Comparator NAME_INSENSITIVE_REVERSE = new ReverseComparator(NAME_INSENSITIVE_COMPARATOR);
+    public static final Comparator<File> NAME_INSENSITIVE_REVERSE = new ReverseComparator(NAME_INSENSITIVE_COMPARATOR);
 
     /** System sensitive name comparator instance (see {@link IOCase#SYSTEM}) */
-    public static final Comparator NAME_SYSTEM_COMPARATOR = new NameFileComparator(IOCase.SYSTEM);
+    public static final Comparator<File> NAME_SYSTEM_COMPARATOR = new NameFileComparator(IOCase.SYSTEM);
 
     /** Reverse system sensitive name comparator instance (see {@link IOCase#SYSTEM}) */
-    public static final Comparator NAME_SYSTEM_REVERSE = new ReverseComparator(NAME_SYSTEM_COMPARATOR);
+    public static final Comparator<File> NAME_SYSTEM_REVERSE = new ReverseComparator(NAME_SYSTEM_COMPARATOR);
 
     /** Whether the comparison is case sensitive. */
     private final IOCase caseSensitivity;
@@ -91,16 +91,14 @@ public NameFileComparator(IOCase caseSensitivity) {
     /**
      * Compare the names of two files with the specified case sensitivity.
      * 
-     * @param obj1 The first file to compare
-     * @param obj2 The second file to compare
+     * @param file1 The first file to compare
+     * @param file2 The second file to compare
      * @return a negative value if the first file's name
      * is less than the second, zero if the names are the
      * same and a positive value if the first files name
      * is greater than the second file.
      */
-    public int compare(Object obj1, Object obj2) {
-        File file1 = (File)obj1;
-        File file2 = (File)obj2;
+    public int compare(File file1, File file2) {
         return caseSensitivity.checkCompareTo(file1.getName(), file2.getName());
     }
 }