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

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

    /** Method to convert a list of nodes from the DOM model into a node array. This is quite useful as using a <strong>NodeList</strong> is problematic if you wish to traverse the tree while editing. Because they are 'live' representations of the model you are editing, it is easy to drop out of for loops early or run off the ends of arrays.
     * @param node_list A <strong>NodeList</strong> representing the <strong>Node</strong>s we want to iterate through.
     * @return A brand new <strong>Node[]</strong> with the first <strong>Node</strong> in the <strong>NodeList</strong> at the head.
     * @see org.w3c.dom.Node
     * @see org.w3c.dom.NodeList
     */
    static public Node[] nodeListToNodeArray(NodeList node_list) {
    Node nodes[] = null;
    for(int i = 0; i < node_list.getLength(); i++) {
        nodes = add(nodes, node_list.item(i));
    }
    return nodes;
    }
    /** 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());
    }
    }
}