source: trunk/gli/src/org/greenstone/gatherer/util/ArrayTools.java@ 13535

/* GPL_HEADER */
package org.greenstone.gatherer.util;

/**************************************************************************************
 * Title:        Gatherer
 * Description:  The Gatherer: a tool for gathering and enriching a digital collection.
 * Company:      The University of Waikato
 * Written:        /  /01
 * Revised:      16/08/02 Improved
 **************************************************************************************/
import java.awt.*;
import java.io.*;
import java.util.*;
import javax.swing.filechooser.*;
import org.w3c.dom.*;

/** This utility class contains a series of static methods for common array type manipulations including appending, casting and changing between containers.
 * @author John Thompson
 * @version 2.3
 */
public class ArrayTools {

    /** Append a Component onto an array of Components. */
    static public Component[] add(Component[] a, Component b) {
    Component[] c = null;
    if(a != null && b != null) {
        c = new Component[a.length + 1];
        System.arraycopy(a, 0, c, 0, a.length);
        c[c.length - 1] = b;
    }
    else if(a == null && b != null) {
        c = new Component[1];
        c[0] = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
    /** This method efficiently appends a new element onto the end of a element array.
     * @param a The initial <strong>Element[]</strong>.
     * @param b The new <strong>Element</strong>.
     * @return An <strong>Element[]</strong> containing a followed by b.
     */
    static public Element[] add(Element a[], Element b) {
    Element[] c = null;
    if(a != null && b != null) {
        c = new Element[a.length + 1];
        System.arraycopy(a, 0, c, 0, a.length);
        c[c.length - 1] = b;
    }
    else if(a == null && b != null) {
        c = new Element[1];
        c[0] = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
    /** This method efficently appends one element array onto the end of another.
     * @param a The initial <strong>Element[]</strong>.
     * @param b The <strong>Element[]</strong> to append.
     * @return An <strong>Element[]</strong> containing a followed by b.
     */
    static public Element[] add(Element a[], Element b[]) {
    Element[] c = null;
    if(a != null && b != null) {
        c = new Element[a.length + b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
    }
    else if(a == null && b != null) {
        c = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
    /** This method efficiently appends a new file onto the end of a file array.
     * @param a The initial <strong>File[]</strong>.
     * @param b The new <strong>File</strong>.
     * @return A <strong>File[]</strong> containing a followed by b.
     */
    static public File[] add(File a[], File b) {
    File[] c = null;
    if(a != null && b != null) {
        c = new File[a.length + 1];
        System.arraycopy(a, 0, c, 0, a.length);
        c[c.length - 1] = b;
    }
    else if(a == null && b != null) {
        c = new File[1];
        c[0] = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
    /** This method efficently appends one file array onto the end of another.
     * @param a The initial <strong>File[]</strong>.
     * @param b The <strong>File[]</strong> to append.
     * @return A <strong>File[]</strong> containing a followed by b.
     */
    static public File[] add(File a[], File b[]) {
    File[] c = null;
    if(a != null && b != null) {
        c = new File[a.length + b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
    }
    else if(a == null && b != null) {
        c = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }


    /** This method efficiently appends a new node onto the end of a node array.
     * @param a The initial <strong>Node[]</strong>.
     * @param b The new <strong>Node</strong>.
     * @return A <strong>Node[]</strong> containing a followed by b.
     */
    static public Node[] add(Node a[], Node b) {
    Node[] c = null;
    if(a != null && b != null) {
        c = new Node[a.length + 1];
        System.arraycopy(a, 0, c, 0, a.length);
        c[c.length - 1] = b;
    }
    else if(a == null && b != null) {
        c = new Node[1];
        c[0] = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
    /** This method efficently appends one node array onto the end of another.
     * @param a The initial <strong>Node[]</strong>.
     * @param b The <strong>Node[]</strong> to append.
     * @return A <strong>Node[]</strong> containing a followed by b.
     */
    static public Node[] add(Node a[], Node b[]) {
    Node[] c = null;
    if(a != null && b != null) {
        c = new Node[a.length + b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
    }
    else if(a == null && b != null) {
        c = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
     
    /** This method efficiently appends a new string onto the end of a string array.
     * @param a The initial <strong>String[]</strong>.
     * @param b The new <strong>String</strong>.
     * @return A <strong>String[]</strong> containing a followed by b.
     */
    static public String[] add(String a[], String b) {
    String[] c = null;
    if(a != null && b != null) {
        c = new String[a.length + 1];
        System.arraycopy(a, 0, c, 0, a.length);
        c[c.length - 1] = b;
    }
    else if(a == null && b != null) {
        c = new String[1];
        c[0] = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
    /** This method efficently appends one string array onto the end of another.
     * @param a The initial <strong>String[]</strong>.
     * @param b The <strong>String[]</strong> to append.
     * @return A <strong>String[]</strong> containing a followed by b.
     */
    static public String[] add(String a[], String b[]) {
    String[] c = null;
    if(a != null && b != null) {
        c = new String[a.length + b.length];
        System.arraycopy(a, 0, c, 0, a.length);
        System.arraycopy(b, 0, c, a.length, b.length);
    }
    else if(a == null && b != null) {
        c = b;
    }
    else if(a != null && b == null) {
        c = a;
    }
    return c;
    }
    /** This method takes an array list and creates a string array.
     * @param a An <strong>ArrayList</strong> containing hopefully <strong>String</strong> or else this will fail.
     * @return A <strong>String[]</strong> or <i>null</i> if the array could not be created.
     */
    static public String[] arrayListToStringArray(ArrayList a) {
    String array[] = new String[a.size()];
    for(int i = 0; i < array.length; i++) {
        array[i] = (String)a.get(i);
    }
    return array;
    }

    static public File[] filter(File[] files, String pattern, boolean exclude) {
    int write_ptr = 0;
    ///ystem.err.println("Filtering by '" + pattern + "', Exclude? " + exclude + " :");
    for(int read_ptr = 0; read_ptr < files.length; read_ptr++) {
        File current = files[read_ptr];
        files[write_ptr] = current;
        ///ystem.err.print("Testing " + current.getName() + " -> ");
        // Determine whether we move the write pointer or not.
        if(current.getName().toLowerCase().matches(pattern)) {
        if(!exclude) {
            ///ystem.err.println("Match, Exclude.");
            write_ptr++;  
        }
        else {
            ///ystem.err.println("Match, Include.");
        }
        }
        else {
        // You can't exclude folders with an inclusion filter!
        if(exclude || current.isDirectory()) {
            ///ystem.err.println("Nonmatch, Exclude.");
            write_ptr++;
        }
        else {
            ///ystem.err.println("Nonmatch, Include.");
        }
        }
    }
    File[] result = new File[write_ptr];
    System.arraycopy(files, 0, result, 0, result.length);
    pattern = null;
    files = null;
    return result;
    }


    /** Transforms an Object array into a single string of the form '[o1,o2,...,on]'.
     * @param objects An <strong>Object[]</strong>. Note that the objects in this array must support toString() reasonably.
     * @return A <strong>String</strong> representing the given array.
     */
    static public String objectArrayToString(Object objects[]) {
    StringBuffer result = new StringBuffer("[");
    for(int i = 0; i < objects.length; i++) {
        result.append(objects[i].toString());
        if(i < objects.length - 1) {
        result.append(",");
        }
    }
    result.append("]");
    return result.toString();
    }


    /** 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);
        }
    }

    // Sort files
    Object[] files = files_list.toArray();
    Arrays.sort(files, comparator);

    // Sort non-files
    Object[] non_files = non_files_list.toArray();
    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 {

    /** 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.
     */
    public int compare(Object o1, Object o2)
    {
        File f1 = (File) o1;
        File f2 = (File) o2;

        return f1.getName().compareToIgnoreCase(f2.getName());
    }
    }
}