[33053] | 1 | /* GPL_HEADER */
|
---|
| 2 | package org.greenstone.gatherer.util;
|
---|
| 3 |
|
---|
| 4 | /**************************************************************************************
|
---|
| 5 | * Title: Gatherer
|
---|
| 6 | * Description: The Gatherer: a tool for gathering and enriching a digital collection.
|
---|
| 7 | * Company: The University of Waikato
|
---|
| 8 | * Written: / /01
|
---|
| 9 | * Revised: 16/08/02 Improved
|
---|
| 10 | **************************************************************************************/
|
---|
| 11 | import java.awt.*;
|
---|
| 12 | import java.io.*;
|
---|
| 13 | import java.util.*;
|
---|
| 14 | import javax.swing.filechooser.*;
|
---|
| 15 | import org.w3c.dom.*;
|
---|
| 16 |
|
---|
| 17 | /** This utility class contains a series of static methods for common array type manipulations including appending, casting and changing between containers.
|
---|
| 18 | * @author John Thompson
|
---|
| 19 | * @version 2.3
|
---|
| 20 | */
|
---|
| 21 | public class ArrayTools {
|
---|
| 22 |
|
---|
| 23 | /** Append a Component onto an array of Components. */
|
---|
| 24 | static public Component[] add(Component[] a, Component b) {
|
---|
| 25 | Component[] c = null;
|
---|
| 26 | if(a != null && b != null) {
|
---|
| 27 | c = new Component[a.length + 1];
|
---|
| 28 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 29 | c[c.length - 1] = b;
|
---|
| 30 | }
|
---|
| 31 | else if(a == null && b != null) {
|
---|
| 32 | c = new Component[1];
|
---|
| 33 | c[0] = b;
|
---|
| 34 | }
|
---|
| 35 | else if(a != null && b == null) {
|
---|
| 36 | c = a;
|
---|
| 37 | }
|
---|
| 38 | return c;
|
---|
| 39 | }
|
---|
| 40 | /** This method efficiently appends a new element onto the end of a element array.
|
---|
| 41 | * @param a The initial <strong>Element[]</strong>.
|
---|
| 42 | * @param b The new <strong>Element</strong>.
|
---|
| 43 | * @return An <strong>Element[]</strong> containing a followed by b.
|
---|
| 44 | */
|
---|
| 45 | static public Element[] add(Element a[], Element b) {
|
---|
| 46 | Element[] c = null;
|
---|
| 47 | if(a != null && b != null) {
|
---|
| 48 | c = new Element[a.length + 1];
|
---|
| 49 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 50 | c[c.length - 1] = b;
|
---|
| 51 | }
|
---|
| 52 | else if(a == null && b != null) {
|
---|
| 53 | c = new Element[1];
|
---|
| 54 | c[0] = b;
|
---|
| 55 | }
|
---|
| 56 | else if(a != null && b == null) {
|
---|
| 57 | c = a;
|
---|
| 58 | }
|
---|
| 59 | return c;
|
---|
| 60 | }
|
---|
| 61 | /** This method efficently appends one element array onto the end of another.
|
---|
| 62 | * @param a The initial <strong>Element[]</strong>.
|
---|
| 63 | * @param b The <strong>Element[]</strong> to append.
|
---|
| 64 | * @return An <strong>Element[]</strong> containing a followed by b.
|
---|
| 65 | */
|
---|
| 66 | static public Element[] add(Element a[], Element b[]) {
|
---|
| 67 | Element[] c = null;
|
---|
| 68 | if(a != null && b != null) {
|
---|
| 69 | c = new Element[a.length + b.length];
|
---|
| 70 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 71 | System.arraycopy(b, 0, c, a.length, b.length);
|
---|
| 72 | }
|
---|
| 73 | else if(a == null && b != null) {
|
---|
| 74 | c = b;
|
---|
| 75 | }
|
---|
| 76 | else if(a != null && b == null) {
|
---|
| 77 | c = a;
|
---|
| 78 | }
|
---|
| 79 | return c;
|
---|
| 80 | }
|
---|
| 81 | /** This method efficiently appends a new file onto the end of a file array.
|
---|
| 82 | * @param a The initial <strong>File[]</strong>.
|
---|
| 83 | * @param b The new <strong>File</strong>.
|
---|
| 84 | * @return A <strong>File[]</strong> containing a followed by b.
|
---|
| 85 | */
|
---|
| 86 | static public File[] add(File a[], File b) {
|
---|
| 87 | File[] c = null;
|
---|
| 88 | if(a != null && b != null) {
|
---|
| 89 | c = new File[a.length + 1];
|
---|
| 90 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 91 | c[c.length - 1] = b;
|
---|
| 92 | }
|
---|
| 93 | else if(a == null && b != null) {
|
---|
| 94 | c = new File[1];
|
---|
| 95 | c[0] = b;
|
---|
| 96 | }
|
---|
| 97 | else if(a != null && b == null) {
|
---|
| 98 | c = a;
|
---|
| 99 | }
|
---|
| 100 | return c;
|
---|
| 101 | }
|
---|
| 102 | /** This method efficently appends one file array onto the end of another.
|
---|
| 103 | * @param a The initial <strong>File[]</strong>.
|
---|
| 104 | * @param b The <strong>File[]</strong> to append.
|
---|
| 105 | * @return A <strong>File[]</strong> containing a followed by b.
|
---|
| 106 | */
|
---|
| 107 | static public File[] add(File a[], File b[]) {
|
---|
| 108 | File[] c = null;
|
---|
| 109 | if(a != null && b != null) {
|
---|
| 110 | c = new File[a.length + b.length];
|
---|
| 111 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 112 | System.arraycopy(b, 0, c, a.length, b.length);
|
---|
| 113 | }
|
---|
| 114 | else if(a == null && b != null) {
|
---|
| 115 | c = b;
|
---|
| 116 | }
|
---|
| 117 | else if(a != null && b == null) {
|
---|
| 118 | c = a;
|
---|
| 119 | }
|
---|
| 120 | return c;
|
---|
| 121 | }
|
---|
| 122 |
|
---|
| 123 |
|
---|
| 124 | /** This method efficiently appends a new node onto the end of a node array.
|
---|
| 125 | * @param a The initial <strong>Node[]</strong>.
|
---|
| 126 | * @param b The new <strong>Node</strong>.
|
---|
| 127 | * @return A <strong>Node[]</strong> containing a followed by b.
|
---|
| 128 | */
|
---|
| 129 | static public Node[] add(Node a[], Node b) {
|
---|
| 130 | Node[] c = null;
|
---|
| 131 | if(a != null && b != null) {
|
---|
| 132 | c = new Node[a.length + 1];
|
---|
| 133 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 134 | c[c.length - 1] = b;
|
---|
| 135 | }
|
---|
| 136 | else if(a == null && b != null) {
|
---|
| 137 | c = new Node[1];
|
---|
| 138 | c[0] = b;
|
---|
| 139 | }
|
---|
| 140 | else if(a != null && b == null) {
|
---|
| 141 | c = a;
|
---|
| 142 | }
|
---|
| 143 | return c;
|
---|
| 144 | }
|
---|
| 145 | /** This method efficently appends one node array onto the end of another.
|
---|
| 146 | * @param a The initial <strong>Node[]</strong>.
|
---|
| 147 | * @param b The <strong>Node[]</strong> to append.
|
---|
| 148 | * @return A <strong>Node[]</strong> containing a followed by b.
|
---|
| 149 | */
|
---|
| 150 | static public Node[] add(Node a[], Node b[]) {
|
---|
| 151 | Node[] c = null;
|
---|
| 152 | if(a != null && b != null) {
|
---|
| 153 | c = new Node[a.length + b.length];
|
---|
| 154 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 155 | System.arraycopy(b, 0, c, a.length, b.length);
|
---|
| 156 | }
|
---|
| 157 | else if(a == null && b != null) {
|
---|
| 158 | c = b;
|
---|
| 159 | }
|
---|
| 160 | else if(a != null && b == null) {
|
---|
| 161 | c = a;
|
---|
| 162 | }
|
---|
| 163 | return c;
|
---|
| 164 | }
|
---|
| 165 |
|
---|
| 166 | /** This method efficiently appends a new string onto the end of a string array.
|
---|
| 167 | * @param a The initial <strong>String[]</strong>.
|
---|
| 168 | * @param b The new <strong>String</strong>.
|
---|
| 169 | * @return A <strong>String[]</strong> containing a followed by b.
|
---|
| 170 | */
|
---|
| 171 | static public String[] add(String a[], String b) {
|
---|
| 172 | String[] c = null;
|
---|
| 173 | if(a != null && b != null) {
|
---|
| 174 | c = new String[a.length + 1];
|
---|
| 175 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 176 | c[c.length - 1] = b;
|
---|
| 177 | }
|
---|
| 178 | else if(a == null && b != null) {
|
---|
| 179 | c = new String[1];
|
---|
| 180 | c[0] = b;
|
---|
| 181 | }
|
---|
| 182 | else if(a != null && b == null) {
|
---|
| 183 | c = a;
|
---|
| 184 | }
|
---|
| 185 | return c;
|
---|
| 186 | }
|
---|
| 187 | /** This method efficently appends one string array onto the end of another.
|
---|
| 188 | * @param a The initial <strong>String[]</strong>.
|
---|
| 189 | * @param b The <strong>String[]</strong> to append.
|
---|
| 190 | * @return A <strong>String[]</strong> containing a followed by b.
|
---|
| 191 | */
|
---|
| 192 | static public String[] add(String a[], String b[]) {
|
---|
| 193 | String[] c = null;
|
---|
| 194 | if(a != null && b != null) {
|
---|
| 195 | c = new String[a.length + b.length];
|
---|
| 196 | System.arraycopy(a, 0, c, 0, a.length);
|
---|
| 197 | System.arraycopy(b, 0, c, a.length, b.length);
|
---|
| 198 | }
|
---|
| 199 | else if(a == null && b != null) {
|
---|
| 200 | c = b;
|
---|
| 201 | }
|
---|
| 202 | else if(a != null && b == null) {
|
---|
| 203 | c = a;
|
---|
| 204 | }
|
---|
| 205 | return c;
|
---|
| 206 | }
|
---|
| 207 | /** This method takes an array list and creates a string array.
|
---|
| 208 | * @param a An <strong>ArrayList</strong> containing hopefully <strong>String</strong> or else this will fail.
|
---|
| 209 | * @return A <strong>String[]</strong> or <i>null</i> if the array could not be created.
|
---|
| 210 | */
|
---|
| 211 | static public String[] arrayListToStringArray(ArrayList a) {
|
---|
| 212 | String array[] = new String[a.size()];
|
---|
| 213 | for(int i = 0; i < array.length; i++) {
|
---|
| 214 | array[i] = (String)a.get(i);
|
---|
| 215 | }
|
---|
| 216 | return array;
|
---|
| 217 | }
|
---|
| 218 |
|
---|
| 219 | static public File[] filter(File[] files, String pattern, boolean exclude) {
|
---|
| 220 | int write_ptr = 0;
|
---|
| 221 | ///ystem.err.println("Filtering by '" + pattern + "', Exclude? " + exclude + " :");
|
---|
| 222 | for(int read_ptr = 0; read_ptr < files.length; read_ptr++) {
|
---|
| 223 | File current = files[read_ptr];
|
---|
| 224 | files[write_ptr] = current;
|
---|
| 225 | ///ystem.err.print("Testing " + current.getName() + " -> ");
|
---|
| 226 | // Determine whether we move the write pointer or not.
|
---|
| 227 | if(current.getName().toLowerCase().matches(pattern)) {
|
---|
| 228 | if(!exclude) {
|
---|
| 229 | ///ystem.err.println("Match, Exclude.");
|
---|
| 230 | write_ptr++;
|
---|
| 231 | }
|
---|
| 232 | else {
|
---|
| 233 | ///ystem.err.println("Match, Include.");
|
---|
| 234 | }
|
---|
| 235 | }
|
---|
| 236 | else {
|
---|
| 237 | // You can't exclude folders with an inclusion filter!
|
---|
| 238 | if(exclude || current.isDirectory()) {
|
---|
| 239 | ///ystem.err.println("Nonmatch, Exclude.");
|
---|
| 240 | write_ptr++;
|
---|
| 241 | }
|
---|
| 242 | else {
|
---|
| 243 | ///ystem.err.println("Nonmatch, Include.");
|
---|
| 244 | }
|
---|
| 245 | }
|
---|
| 246 | }
|
---|
| 247 | File[] result = new File[write_ptr];
|
---|
| 248 | System.arraycopy(files, 0, result, 0, result.length);
|
---|
| 249 | pattern = null;
|
---|
| 250 | files = null;
|
---|
| 251 | return result;
|
---|
| 252 | }
|
---|
| 253 |
|
---|
| 254 |
|
---|
| 255 | /** Transforms an Object array into a single string of the form '[o1,o2,...,on]'.
|
---|
| 256 | * @param objects An <strong>Object[]</strong>. Note that the objects in this array must support toString() reasonably.
|
---|
| 257 | * @return A <strong>String</strong> representing the given array.
|
---|
| 258 | */
|
---|
| 259 | static public String objectArrayToString(Object objects[]) {
|
---|
| 260 | StringBuffer result = new StringBuffer("[");
|
---|
| 261 | for(int i = 0; i < objects.length; i++) {
|
---|
| 262 | result.append(objects[i].toString());
|
---|
| 263 | if(i < objects.length - 1) {
|
---|
| 264 | result.append(",");
|
---|
| 265 | }
|
---|
| 266 | }
|
---|
| 267 | result.append("]");
|
---|
| 268 | return result.toString();
|
---|
| 269 | }
|
---|
| 270 |
|
---|
| 271 |
|
---|
| 272 | /** Sorts an array of files, putting non-files first. Case insensitive.
|
---|
| 273 | * @param files_to_sort The File[] to be sorted.
|
---|
| 274 | */
|
---|
| 275 | static public void sort(File[] files_to_sort)
|
---|
| 276 | {
|
---|
| 277 | // Return if there is nothing to sort
|
---|
| 278 | if (files_to_sort == null || files_to_sort.length <= 1) {
|
---|
| 279 | return;
|
---|
| 280 | }
|
---|
| 281 |
|
---|
| 282 | FileSystemView fileSystemView = FileSystemView.getFileSystemView();
|
---|
| 283 | FileComparator comparator = new FileComparator();
|
---|
| 284 |
|
---|
| 285 | // Separate the file system roots and directories from the files, and sort separately
|
---|
| 286 | ArrayList files_list = new ArrayList((files_to_sort.length * 3) / 4);
|
---|
| 287 | ArrayList non_files_list = new ArrayList((files_to_sort.length) / 4);
|
---|
| 288 | for (int i = 0; i < files_to_sort.length; i++) {
|
---|
| 289 | File file = files_to_sort[i];
|
---|
| 290 |
|
---|
| 291 | // File is a system root
|
---|
| 292 | if (fileSystemView.isFileSystemRoot(file)) {
|
---|
| 293 | non_files_list.add(file);
|
---|
| 294 | }
|
---|
| 295 | // File is a directory
|
---|
| 296 | else if (file.isDirectory()) {
|
---|
| 297 | non_files_list.add(file);
|
---|
| 298 | }
|
---|
| 299 | // File is an actual file
|
---|
| 300 | else {
|
---|
| 301 | files_list.add(file);
|
---|
| 302 | }
|
---|
| 303 | }
|
---|
| 304 |
|
---|
| 305 | // Sort files
|
---|
| 306 | Object[] files = files_list.toArray();
|
---|
| 307 | Arrays.sort(files, comparator);
|
---|
| 308 |
|
---|
| 309 | // Sort non-files
|
---|
| 310 | Object[] non_files = non_files_list.toArray();
|
---|
| 311 | Arrays.sort(non_files, comparator);
|
---|
| 312 |
|
---|
| 313 | // Merge the results, putting non-files before files
|
---|
| 314 | int j = 0;
|
---|
| 315 | for (int i = 0; i < non_files.length; i++) {
|
---|
| 316 | files_to_sort[j++] = (File) non_files[i];
|
---|
| 317 | }
|
---|
| 318 | for (int i = 0; i < files.length; i++) {
|
---|
| 319 | files_to_sort[j++] = (File) files[i];
|
---|
| 320 | }
|
---|
| 321 | }
|
---|
| 322 |
|
---|
| 323 |
|
---|
| 324 | /** Comparator used to order files. */
|
---|
| 325 | static private class FileComparator
|
---|
| 326 | implements Comparator {
|
---|
| 327 |
|
---|
| 328 | /** Compare two files in terms of ordering of their paths.
|
---|
| 329 | * @param o1 The <strong>Object</strong> that represents the first file.
|
---|
| 330 | * @param o2 The other <strong>Object</strong>, also a file.
|
---|
| 331 | * @return An <i>int</i> which is <1, 0 or >1 if o1 is <o2, =o2 or >o2 respectively.
|
---|
| 332 | */
|
---|
| 333 | public int compare(Object o1, Object o2)
|
---|
| 334 | {
|
---|
| 335 | File f1 = (File) o1;
|
---|
| 336 | File f2 = (File) o2;
|
---|
| 337 |
|
---|
| 338 | return f1.getName().compareToIgnoreCase(f2.getName());
|
---|
| 339 | }
|
---|
| 340 | }
|
---|
| 341 | }
|
---|