Changeset 7121

Timestamp:

2004-03-26T15:26:24+12:00 (20 years ago)

Author:

mdewsnip

Message:

A much improved method for sorting file nodes into alphabetical order, with directories coming first. The old version was very very slow on Windows 95 and 98 computers with a large number of files (>3000) in the directory; this version is still slow, but a great deal better than before.

Location:

trunk/gli/src/org/greenstone/gatherer

Files:

• file/FileNode.java (modified) (3 diffs)
• util/ArrayTools.java (modified) (1 diff)

trunk/gli/src/org/greenstone/gatherer/file/FileNode.java

@@ -36 +36 @@
 
     public FileNode(File file) {
-    ///atherer.println("New FileNode(" + file.getAbsolutePath() + ")");
+    // System.err.println("New FileNode(" + file.getAbsolutePath() + ")");
     this.file = file;
     }
@@ -306 +306 @@
         File[] files = file.listFiles();
         if(files != null && files.length > 0) {
-            ArrayTools tools = new ArrayTools();
             // Sort the remaining files.
-            tools.sort(files, true);
+            System.err.println("Number of files to sort: " + files.length);
+            ArrayTools.sort(files);
+            System.err.println("Files sorted.");
             // Now add them to children.
             raw_children = new ArrayList();
@@ -316 +317 @@
             raw_children.add(child);
             }
+
             // Apply the filters set in the model.
             //if(model != null) {
             FileFilter[] filters = model.getFilters();
             for(int i = 0; filters != null && i < filters.length; i++) {
-            files = tools.filter(files, filters[i].filter, filters[i].exclude);
+            files = ArrayTools.filter(files, filters[i].filter, filters[i].exclude);
             }
             //}
 
-            // Finally remove any files whose canonical path do not match their absolute one (ie symbolic links). We only do this test under linux, because under windows there is no such thing as a symbolic link, and instead we suffer difficulties with the 16bit truncated file paths not being the same as the canonical ones (i.e Program Files => Progra~1).
-            /* This test to eliminate infinite recursions causes more problems than it solves
-            if(!Utility.isWindows()) {
-            for(int k = files.length; k != 0; k--) {
-                try {
-                if(!files[k-1].getAbsolutePath().equals(files[k-1].getCanonicalPath())) {
-                    ///ystem.err.println("For file: " + files[k-1].getName());
-                    ///ystem.err.println("Absolute Path:  " + files[k-1].getAbsolutePath());
-                    ///ystem.err.println("Canonical Path: " + files[k-1].getCanonicalPath());
-                    files = ArrayTools.remove(files, (k-1));
-                }
-                }
-                catch (IOException exception) {
-                ///atherer.printStackTrace(exception);
-                }
-            }
-            }
-            */
             // Now add them to children.
             for(int i = 0; i < files.length; i++) {

trunk/gli/src/org/greenstone/gatherer/util/ArrayTools.java

@@ -408 +408 @@
     }
 
-    /** Sorts an array of files. */
-    static public void sort(File[] files) {
-    sort(files, false);
-    }
-
-    /** Sorts an array of files. Can also to instructed to list directories first. Case insensitive.
-     * @param files The File[] to be sorted.
-     * @param directories_first true if you want to directories to be listed first.
-     */
-    static public void sort(File[] files, boolean directories_first) {
-    if(files != null && files.length > 1) {
-        FileComparator comparator = new FileComparator(directories_first);
-        Arrays.sort(files, comparator);
-    }         
-    }
+
+    /** Sorts an array of files, putting non-files first. Case insensitive.
+     * @param files_to_sort The File[] to be sorted.
+     */
+    static public void sort(File[] files_to_sort)
+    {
+    // Return if there is nothing to sort
+    if (files_to_sort == null || files_to_sort.length <= 1) {
+        return;
+    }
+
+    FileSystemView fileSystemView = FileSystemView.getFileSystemView();
+    FileComparator comparator = new FileComparator();
+
+    // Separate the file system roots and directories from the files, and sort separately
+    ArrayList files_list = new ArrayList((files_to_sort.length * 3) / 4);
+    ArrayList non_files_list = new ArrayList((files_to_sort.length) / 4);
+    for (int i = 0; i < files_to_sort.length; i++) {
+        File file = files_to_sort[i];
+
+        // File is a system root
+        if (fileSystemView.isFileSystemRoot(file)) {
+        non_files_list.add(file);
+        }
+        // File is a directory
+        else if (file.isDirectory()) {
+        non_files_list.add(file);
+        }
+        // File is an actual file
+        else {
+        files_list.add(file);
+        }
+    }
+    System.err.println("Number of files: " + files_list.size());
+    System.err.println("Number of non-files: " + non_files_list.size());
+
+    Object[] files = files_list.toArray();
+    Object[] non_files = non_files_list.toArray();
+
+    // Sort files
+    Arrays.sort(files, comparator);
+
+    // Sort non-files
+    Arrays.sort(non_files, comparator);
+
+    // Merge the results, putting non-files before files
+    int j = 0;
+    for (int i = 0; i < non_files.length; i++) {
+        files_to_sort[j++] = (File) non_files[i];
+    }
+    for (int i = 0; i < files.length; i++) {
+        files_to_sort[j++] = (File) files[i];
+    }
+    }
+
 
     /** Comparator used to order files. */
     static private class FileComparator
     implements Comparator {
-    private boolean directories_first = false;
-
-    public FileComparator(boolean directories_first) {
-        this.directories_first = directories_first;
-    }
+
     /** Compare two files in terms of ordering of their paths.
      * @param o1 The <strong>Object</strong> that represents the first file.
      * @param o2 The other <strong>Object</strong>, also a file.
-     * @return An <i>int</i> which is <1, 0 or >1 if o1 is < o2, = o2 or > o2 respectively.
+     * @return An <i>int</i> which is <1, 0 or >1 if o1 is <o2, =o2 or >o2 respectively.
      */
-    public int compare(Object o1, Object o2) {
-        int result = 0;
+    public int compare(Object o1, Object o2)
+    {
         File f1 = (File) o1;
-        String n1 = f1.getName().toLowerCase();
         File f2 = (File) o2;
-        String n2 = f2.getName().toLowerCase();
-                // Special checks for system roots as these include removable media drives and thus we should never attempt to call isDirectory until the user explicitly attempts to map drive.
-        boolean f1_system_root = FileSystemView.getFileSystemView().isFileSystemRoot(f1);
-        boolean f2_system_root = FileSystemView.getFileSystemView().isFileSystemRoot(f2);
-        if((f1_system_root && f2_system_root) || (!f2_system_root && f1_system_root && f2.isDirectory()) || (!f1_system_root && f1.isDirectory() && f2_system_root) || (f1.isDirectory() && f2.isDirectory()) || (f1.isFile() && f2.isFile())) {
-        result = n1.compareTo(n2);
-        }
-        else if(f1_system_root || f1.isDirectory()) {
-        result = -1;
-        }
-        else {
-        result = 1;
-        }
-        return result;
-    }
-    /** Compare two files for equality, in terms of their file paths.
-     * @param obj The <strong>Object</strong> representing the file we are about to compare ourselves to.
-     * @return <i>true</i> if we equal the given file, <i>false</i> otherwise.
-     */
-    public boolean equals(Object obj) {
-        return (compare(this, obj) == 0);
+
+        return f1.getName().compareToIgnoreCase(f2.getName());
     }
     }