/*
 *
 *  $Revision: 1315 $
 *  $Date: 2020-03-19 14:33:30 -0700 (Thu, 19 Mar 2020) $
 *  $Locker:  $
 *
 *
 *  Written by Tom Gutwin - WebARTS Design.
 *  http://www.webarts.bc.ca
 *  Copyright (C) 2001-2013 WebARTS Design, North Vancouver Canada
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; either version 2 of the License, or
 *  (at your option) any later version.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
 */
package ca.bc.webarts.widgets;

import ca.bc.webarts.widgets.ExampleFileFilter;

import ca.bc.webarts.tools.Log;
import ca.bc.webarts.tools.StreamGobbler;

import gnu.regexp.RE;
import gnu.regexp.REException;

import com.aftexsw.util.bzip.BZip;

import java.awt.Component;
import java.awt.Frame;
import java.awt.Image;
import java.awt.Toolkit;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.PrintStream;
import java.net.InetAddress;
import java.net.MalformedURLException;
import java.net.URL;
import java.net.UnknownHostException;
import java.nio.charset.Charset;
import java.nio.file.Files;
import java.nio.file.Paths;
import java.nio.file.StandardOpenOption;
import java.text.DecimalFormat;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.Collections;
import java.util.Comparator;
import java.util.Date;
import java.util.Enumeration;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.Vector;
import java.util.jar.JarEntry;
import java.util.jar.JarFile;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;
import java.security.MessageDigest;
import java.security.NoSuchAlgorithmException;

import javax.xml.parsers.*;
import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;

import org.w3c.dom.Document;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;

import javax.swing.Icon;
import javax.swing.ImageIcon;
import javax.swing.JFileChooser;
import javax.swing.JFrame;
import javax.swing.SwingUtilities;
import javax.swing.UIManager;

import java.io.*;

import org.apache.tools.ant.util.FileUtils;
import org.apache.tools.ant.taskdefs.Replace;

/*
import org.geotools.referencing.GeodeticCalculator;
import org.geotools.geometry.DirectPosition2D;
import org.geotools.geometry.GeneralDirectPosition;
import org.geotools.referencing.wkt.Parser;
import org.opengis.referencing.crs.CoordinateReferenceSystem;
import org.geotools.referencing.crs.DefaultProjectedCRS;
import org.opengis.referencing.operation.TransformException;
*/

/**
 *  A set of useful utility methods/functions for reuse.
 *
 * @author     Tom Gutwin P.Eng
 */
public class Util
{
  /**  A holder for this clients System File Separator.  */
  public final static String SYSTEM_FILE_SEPERATOR = File.separator;

  /**  A holder for this clients System line termination separator.  */
  public final static String SYSTEM_LINE_SEPERATOR =
                                           System.getProperty("line.separator");

  /**
   *  A constant to specify which dialog to open with the chooseFileDialog.
   */
  public final static short OPEN_DIALOG = 0;

  /**
   *  A constant to specify which dialog to open with the chooseFileDialog.
   */
  public final static short SAVE_DIALOG = 1;

  /**  The VM classpath (used in some methods)..  */
  public static String CLASSPATH = System.getProperty("class.path");

  /**  The users home ditrectory.  */
  public static String USERHOME = System.getProperty("user.home");

  /**  The users pwd ditrectory.  */
  public static String USERDIR = System.getProperty("user.dir");

  /**  A holder This classes name (used when logging).  */
  private static String CLASSNAME = "ca.bc.webarts.widgets.Util";

  /**
   *  the Metal LookAndFeel CONSTANT.
   */
   public static final short METAL_LOOKANDFEEL = 0;

  /**
   *  the Windoze LookAndFeel CONSTANT.
   */
   public static final short WINDOZE_LOOKANDFEEL = 1;

  /**
   *  the Motif LookAndFeel CONSTANT.
   */
   public static final short MOTIF_LOOKANDFEEL = 2;

  /**
   *  the Mac LookAndFeel CONSTANT.
   */
   public static final short MAC_LOOKANDFEEL = 3;

  /**
   *  the Default LookAndFeel CONSTANT. DEFAULT_LOOKANDFEEL = METAL_LOOKANDFEEL
   */
   public static final short DEFAULT_LOOKANDFEEL = METAL_LOOKANDFEEL;

  /**
   *  the Mac LookAndFeel class name
   */
  public static String macClassName =
      "com.sun.java.swing.plaf.mac.MacLookAndFeel";
  /**
   *  the Java LookAndFeel class name
   */
  public static String metalClassName =
      "javax.swing.plaf.metal.MetalLookAndFeel";
  /**
   *  the motif LookAndFeel class name
   */
  public static String motifClassName =
      "com.sun.java.swing.plaf.motif.MotifLookAndFeel";
  /**
   *  the Windoze LookAndFeel class name
   */
  public static String windowsClassName =
      "com.sun.java.swing.plaf.windows.WindowsLookAndFeel";

  /**  Gets a Log instance in case any calling classes are using it.  */
  private static Log log_ = Log.getInstance();

  /**  Class flag signifying if the initUtil method has been called  */
  private static boolean initUtil = false;

  /**  Class flag for the threadWatchdog method to enable the calling user
   *   to stop the watch.  */
  public static boolean watchdogReset = false;
  /**  The temp dir where the zipped files go before archiving. */
  public static String zippedOutputLocation_ = ".";
  /**  The collection of filenames that had errors during compression. */
  public static Vector errorFiles_ = null;

  final static String[] hex = {
    "%00", "%01", "%02", "%03", "%04", "%05", "%06", "%07",
    "%08", "%09", "%0a", "%0b", "%0c", "%0d", "%0e", "%0f",
    "%10", "%11", "%12", "%13", "%14", "%15", "%16", "%17",
    "%18", "%19", "%1a", "%1b", "%1c", "%1d", "%1e", "%1f",
    "%20", "%21", "%22", "%23", "%24", "%25", "%26", "%27",
    "%28", "%29", "%2a", "%2b", "%2c", "%2d", "%2e", "%2f",
    "%30", "%31", "%32", "%33", "%34", "%35", "%36", "%37",
    "%38", "%39", "%3a", "%3b", "%3c", "%3d", "%3e", "%3f",
    "%40", "%41", "%42", "%43", "%44", "%45", "%46", "%47",
    "%48", "%49", "%4a", "%4b", "%4c", "%4d", "%4e", "%4f",
    "%50", "%51", "%52", "%53", "%54", "%55", "%56", "%57",
    "%58", "%59", "%5a", "%5b", "%5c", "%5d", "%5e", "%5f",
    "%60", "%61", "%62", "%63", "%64", "%65", "%66", "%67",
    "%68", "%69", "%6a", "%6b", "%6c", "%6d", "%6e", "%6f",
    "%70", "%71", "%72", "%73", "%74", "%75", "%76", "%77",
    "%78", "%79", "%7a", "%7b", "%7c", "%7d", "%7e", "%7f",
    "%80", "%81", "%82", "%83", "%84", "%85", "%86", "%87",
    "%88", "%89", "%8a", "%8b", "%8c", "%8d", "%8e", "%8f",
    "%90", "%91", "%92", "%93", "%94", "%95", "%96", "%97",
    "%98", "%99", "%9a", "%9b", "%9c", "%9d", "%9e", "%9f",
    "%a0", "%a1", "%a2", "%a3", "%a4", "%a5", "%a6", "%a7",
    "%a8", "%a9", "%aa", "%ab", "%ac", "%ad", "%ae", "%af",
    "%b0", "%b1", "%b2", "%b3", "%b4", "%b5", "%b6", "%b7",
    "%b8", "%b9", "%ba", "%bb", "%bc", "%bd", "%be", "%bf",
    "%c0", "%c1", "%c2", "%c3", "%c4", "%c5", "%c6", "%c7",
    "%c8", "%c9", "%ca", "%cb", "%cc", "%cd", "%ce", "%cf",
    "%d0", "%d1", "%d2", "%d3", "%d4", "%d5", "%d6", "%d7",
    "%d8", "%d9", "%da", "%db", "%dc", "%dd", "%de", "%df",
    "%e0", "%e1", "%e2", "%e3", "%e4", "%e5", "%e6", "%e7",
    "%e8", "%e9", "%ea", "%eb", "%ec", "%ed", "%ee", "%ef",
    "%f0", "%f1", "%f2", "%f3", "%f4", "%f5", "%f6", "%f7",
    "%f8", "%f9", "%fa", "%fb", "%fc", "%fd", "%fe", "%ff"
  };

  /**  Inits the log and some other vars.*/
  private static synchronized void initUtil()
  {
    final String methodName = CLASSNAME + ": initUtil()";

    if (!initUtil || log_ == null)
    {
      //System.out.println("Into the init block");
      log_ = Log.getInstance();
      if (log_ != null)
      {
        //log_.setLogLevel(Log.MAJOR);
        log_.startMethod(methodName);
      }
      CLASSPATH = System.getProperty("java.class.path");
      //System.out.println("In "+methodName);
      initUtil = true;
      if (log_ != null)
      {
        log_.endMethod();
      }

    }
  }


  /**
   *  Ensures that a folder exists.
   *  <TABLE WIDTH="100%" BORDER="0" CELLSPACING="1" CELLPADDING="2">
   *
   *    <TR>
   *
   *      <TDC OLSPAN="2">
   *        <H2>Ensures that a folder exists</H2>
   *      </TD>
   *
   *    </TR>
   *
   *    <TR>
   *
   *      <TD COLSPAN="2">
   *        &nbsp;<BR>
   *        <B>Description:</B> <BR>
   *        use it like this: <br>
   *        ensureFolderExists(new File(fileName).getParentFile());
   *      </TD>
   *
   *    </TR>
   *
   *  </TABLE>
   *
   *
   * @param  folder  The File object to check.
   */
  public static void ensureParentFolderExists(File folder)
  {
    //System.out.println(" 1 Making Dir: "+folder.getAbsolutePath());
    if (folder != null)
    {
      //System.out.println(" 2 Making Dir: "+folder.getAbsolutePath());
      ensureFolderExists(folder.getParentFile());
      //System.out.print(" 3 Making Dir: "+folder.getAbsolutePath());
      boolean suc = folder.mkdir();
      //System.out.println(" -->"+(suc?"Successful":"Failed"));
    }
  }


  public static void ensureFolderExists(File folder)
  {
    //System.out.println(" 1 Making Dir: "+folder.getAbsolutePath());
    if ((folder != null) && !(folder.isDirectory() ))
    {
      //System.out.println(" 2 Making Dir: "+folder.getAbsolutePath());
      ensureFolderExists(folder.getParentFile());
      //System.out.print(" 3 Making Dir: "+folder.getAbsolutePath());
      boolean suc = folder.mkdir();
      //System.out.println(" -->"+(suc?"Successful":"Failed"));
    }
  }


  public static void ensureParentFolderExists(String foldername)
  {
    if (foldername != null && !foldername.equals(""))
    {
      File folder = new File(foldername);
      ensureParentFolderExists(folder);
    }
  }


  public static void ensureFolderExists(String foldername)
  {
    if (foldername != null && !foldername.equals(""))
    {
      File folder = new File(foldername);
      ensureFolderExists(folder);
    }
  }


  /**
   * Renames the specified file to the toFilename in the same directory.
   *
   * @param fromFilename is the absoulte pathname of the file to rename.
   * @param toFilename is the new filename.
   * @return the new absolute filename (including path) OR empty if failure
   **/
  public static String renameFile(String fromFilename, String toFilename)
  {
    String retVal = "";
    if (fromFilename != null && !fromFilename.equals(""))
    {
      if(!fromFilename.contains(SYSTEM_FILE_SEPERATOR))  fromFilename = "."+SYSTEM_FILE_SEPERATOR+fromFilename;
      if(toFilename.contains(SYSTEM_FILE_SEPERATOR)) toFilename.substring(toFilename.lastIndexOf(SYSTEM_FILE_SEPERATOR)+1);
      File fromFile = new File(fromFilename);
      if (fromFile != null && fromFile.exists())
      {
        String foldername = fromFile.getParent();
        File toFile = new File(foldername+File.separator+toFilename);
        if( fromFile.renameTo(toFile))
          retVal = foldername+File.separator+toFilename;
        else System.out.println(" !* RenameFileERROR: File.renameTo failed - "+fromFilename +" to "+foldername+File.separator+toFilename);
        /*else
        {
          // Try Native move call
          String [] ss = {fromFilename,foldername+File.separator+toFilename};
          String ret = executeNativeApp("/bin/mv",ss,false);
          System.out.println(" Native mv: "+ ret);
          retVal = foldername+File.separator+toFilename;
        }*/
      }
      else System.out.println(" !* RenameFileERROR: fromFile is empty or null");
    }
    else System.out.println(" !* RenameFileERROR: fromFilename is empty or null");

    return retVal;
  }


  /**
   * Moves the specified file to the specified directory. It will create
   * the target dir if it does not exist.
   *
   * @param filename is the absoulte pathname of the file to move.
   * @param foldername is the directory to move it to.
   **/
  public static boolean moveFile(String filename, String foldername)
  {
    boolean retVal = false;
    if (foldername != null && !foldername.equals("") &&
        filename != null && !filename.equals(""))
    {
      File fromFile = new File(filename);
      if (fromFile != null && fromFile.exists())
      {
        File folder = new File(foldername);
        ensureFolderExists(folder);
        File toFile = new File(foldername+File.separator+fromFile.getName());
        retVal = fromFile.renameTo(toFile);
        if (!retVal)
        {
          // Try Native move call
          String [] ss = {filename,foldername};
          String ret = executeNativeApp("/bin/mv",ss,false);
          System.out.println(" Native mv: "+ ret);
        }
      }
    }
    return retVal;
  }


  /** Converts an HEX number String to its decimal equivalent.
   * @param str holding the Hex Number string to convert to decimal
   * @return an int holding the decimal equivalent of the passed in HEX numberStr.
   **/
  public static int convertHexNumberStringToDecimal(String str)
  {
    return convertHexNumberStringToDecimal(str, false);
  }


  /** Converts an HEX number String to its decimal equivalent.
   * @param str holding the Hex Number string to convert to decimal
   * @param dumpOut boolean flag to turn some debug output on/off
   * @return an int holding the decimal equivalent of the passed in HEX numberStr.
   **/
  public static int convertHexNumberStringToDecimal(String str,  boolean dumpOut)
  {
    char[] chars = str.toCharArray();
    String out_put = "";

    if (dumpOut) System.out.println("\n      AsciiHex: 0x"+str);
    if (dumpOut) System.out.print(  "       Decimal: ");

    StringBuffer hex = new StringBuffer();
    String hexInt = new String();
    for(int i = 0; i < chars.length; i++)
    {
      out_put = Integer.toHexString((int)chars[i]);
      if (out_put.length()==1) hex.append("0");
      hex.append(out_put);
      if (dumpOut) System.out.print((out_put.length()==1?"0":"")+ out_put);
    }
    hexInt = ""+(Integer.parseInt( hex.toString(), 16));
    if (dumpOut) System.out.println("");
    if (dumpOut) System.out.println( "      Decimal: "+hexInt.toString());

    return Integer.parseInt(hexInt.toString());

    //return Integer.decode("0x"+str);
  }


  /** Converts an ascii String to a hex  String **/
  public static String convertStringToHex(String str){

    char[] chars = str.toCharArray();

    StringBuffer hex = new StringBuffer();
    for(int i = 0; i < chars.length; i++){
      hex.append(Integer.toHexString((int)chars[i]));
    }

    return hex.toString();
  }


  /** Converts a hex String to an ascii String **/
  public static String convertHexToString(String hex){

    StringBuilder sb = new StringBuilder();
    StringBuilder temp = new StringBuilder();

    //49204c6f7665204a617661 split into two characters 49, 20, 4c...
    for( int i=0; i<hex.length()-1; i+=2 ){

        //grab the hex in pairs
        String output = hex.substring(i, (i + 2));
        //convert hex to decimal
        int decimal = Integer.parseInt(output, 16);
        //convert the decimal to character
        sb.append((char)decimal);

        temp.append(decimal);
    }
    System.out.println("Decimal : " + temp.toString());

    return sb.toString();
  }


  /**
   *  A simple byte to Hex String converter.
   *
   * @param  b  The byte to convert
   * @return    The resultant Hex String
   */
  public static String toHEXString(byte b)
  {
    return ("" + "0123456789ABCDEF".charAt(0xf & b >> 4) +
        "0123456789ABCDEF".charAt(b & 0xF));
  }


  /**
   *  A simple int to Hex String converter.
   *
   * @param  s  The int to convert
   * @return    The resultant Hex String
   */
  public static final String toHEXString(int s)
  {
    return Integer.toHexString(s);
    /*if (s < 10)
    {
       return new StringBuffer().
                                append((char)('0' + s)).
                                toString();
    }
    else
    {
       return new StringBuffer().
                                append((char)('A' + (s - 10))).
                                toString();
    }
    */
  }


  /**
   *  A simple int to Hex String converter.
   *
   * @param  num  The int to convert
   * @return    The resultant Hex char array
   */
  public static final char [] toHEXChars(int num)
  {
    String s = toHEXString(num);
    int numChars = s.length();
    char [] retVal = new char[numChars];
    for (int i = 0; i< numChars; i++) retVal[i] = s.charAt(i);
    return retVal;
  }


  /**
   *  A simple int to Hex String converter.
   *
   * @param  num  The int to convert
   * @return    The resultant Hex char array
   */
  public static final char [] toHEXChars(int num, int paddedLength)
  {
    String s = toHEXString(num);
    //System.out.println("toHEXChars("+s+", "+paddedLength+")");
    int numChars = s.length();
    int sRef = 0;
    char [] retVal = new char[paddedLength];
    for (int i = 0; i< paddedLength; i++)
      if(i<(paddedLength-numChars)) retVal[i] = '0';
      else retVal[i] = s.charAt(sRef++);
    return retVal;
  }


  /**
   *  Another simple int to Hex String converter.
   *
   * @param  s  The int to convert
   * @return    The resultant Hex String
   */
  public static final String decimalToHexadecimal(int s)
  {
    StringBuffer retValBuf = new StringBuffer();
    int decimalNumber, remainder, quotient;
    int i = 1, temp;
    byte[] hexadecimalNumber = new byte[100];
    decimalNumber = s;
    quotient = decimalNumber;
    while (quotient != 0)
    {
      temp = (quotient % 16);     //To convert integer into character
      if (temp < 10)
      {
        temp = temp + 48;
      }
      else
      {
        temp = temp + 55;
      }
      hexadecimalNumber[i++] = (byte) temp;
      quotient = quotient / 16;
    }
    //System.out.println();
    //System.out.print("Equivalent hexadecimal value of decimal number " + ( decimalNumber) + ": ");
    for (int j = i - 1; j > 0; j--)
    {
      retValBuf.append((char)(hexadecimalNumber[j]));
      //System.out.print((char)(hexadecimalNumber[j]));
    }
    //System.out.println();
    return retValBuf.toString();
  }


  /**
   *  A simple int to Binary String converter.
   *
   * @param  s  The int to convert
   * @return    The resultant binary String
   */
  public static final String decimalToBinary(int s)
  {
    StringBuffer retValBuf = new StringBuffer();
    int decimalNumber, remainder, quotient;
    int[] binaryNumber = new int[100];
    int i = 1;
    //System.out.print("Enter any decimal number: ");
    decimalNumber = s;
    quotient = decimalNumber;
    while (quotient != 0)
    {
     binaryNumber[i++] = (quotient % 2);
     quotient = quotient / 2;
    }
    System.out.print("Equivalent binary value of decimal number " + (decimalNumber) + ": ");
    for (int j = i - 1; j > 0; j--)
    {
     retValBuf.append(binaryNumber[j]);
     System.out.print(binaryNumber[j]);
    }
    return retValBuf.toString();
  }


    /**
   * Uses Java to compute the MD5 sum of a given input String.
   * @param input is the string to compute
   * @return the MD5Sum in Hexidecimal
   */
  public static String computeMD5Sum(String input)
  {

    String retVal = "";
    try
    {
      StringBuffer sbuf = new StringBuffer();
      MessageDigest md = MessageDigest.getInstance("MD5");
      byte [] raw = md.digest(input.getBytes());

      for (int i = 0; i < raw.length; i++)
      {
        int c = (int) raw[i];
        if (c < 0)
        {
          c = (Math.abs(c) - 1) ^ 255;
        }
        String block = toHEXString(c >>> 4) + toHEXString(c & 15);
        sbuf.append(block);
        retVal = sbuf.toString();
      }
    }
    catch (NoSuchAlgorithmException crapOut)
    {

    }

    return retVal;
  }


  public static String xmlToPrettyString(String xmlString, int indent) throws Exception
  {
    DocumentBuilderFactory documentBuilderFactory = DocumentBuilderFactory.newInstance();
    DocumentBuilder documentBuilder = documentBuilderFactory.newDocumentBuilder();
    Document document = documentBuilder.parse(new InputSource(new StringReader(xmlString)));

    TransformerFactory transformerFactory = TransformerFactory.newInstance();
    Transformer transformer = transformerFactory.newTransformer();
    transformer.setOutputProperty(OutputKeys.ENCODING, "UTF-8");
    if (indent > 0) {
        transformer.setOutputProperty(OutputKeys.INDENT, "yes");
        transformer.setOutputProperty("{http://xml.apache.org/xslt}indent-amount", Integer.toString(indent));
    }
    ByteArrayOutputStream os = new ByteArrayOutputStream();
    Result result = new StreamResult(os);
    Source source = new DOMSource(document);
    transformer.transform(source, result);

    //aClass.outputStreamMethod(os);
    String aString = new String(os.toByteArray(),"UTF-8");
    return aString;
  }


  /**
   *  SetsIcon for the passed in Frame
   *
   * @param  imageFilename  - is the filename for the new icon
   * @param  appFrame       The new iconForApp value
   */
  public static void setIconForApp(JFrame appFrame, String imageFilename)
  {
    setIconForApp(appFrame, Util.class.getResource(imageFilename));
  }
  // end of setIconForApp


  /**
   *  SetsIcon for the passed in Frame
   *
   * @param  imageUrl  - is the URL for the new icon
   * @param  appFrame  The new iconForApp value
   */
  public static void setIconForApp(JFrame appFrame, URL imageUrl)
  {
    ImageIcon image = new ImageIcon(imageUrl);
    appFrame.setIconImage(image.getImage());
    image = null;
  }
  // end of setIconForApp


  /**
   *  Creates a timestamp for the current date. It is in the form of 'year +
   *  "-" + month "-" + date "-" + hour "-" + seconds<br>
   *  For example:  2003-245
   *
   * @return    The CurrentDateTime value.
   */
  public static String createCurrentDateTime()
  {
    Calendar calendar_ = Calendar.getInstance();

    return ""+ calendar_.get(Calendar.YEAR) + "-" +
                calendar_.get(Calendar.MONTH)+ "-" +
                calendar_.get(Calendar.DATE)+ "-" +
                calendar_.get(Calendar. HOUR_OF_DAY )+ "-" +
                calendar_.get(Calendar.MINUTE);
  }


  /**
   *  Creates a timestamp for the current date. It is in the form of 'year +
   *  "-" + dayNum <br>
   *  For example:  2003-245
   *
   * @return    The CurrentTimeStamp value.
   */
  public static String createCurrentDateStamp()
  {
    Calendar calendar_ = Calendar.getInstance();

    return ""+ calendar_.get(Calendar.YEAR) + "-" +
           calendar_.get(Calendar.DAY_OF_YEAR);
  }


  /**
   *  Creates a timestamp for the current date and time. It is in the form of 'year +
   *  "-" + dayNum + "-" + hour + "-" + min + "-" + sec + "-" + millis'.<br>
   *  For example:  2003-245-14-34-52-224
   *
   * @return    The CurrentTimeStamp value.
   */
  public static String createCurrentDateTimeStamp()
  {
    Calendar calendar_ = Calendar.getInstance();

    return ""+ calendar_.get(Calendar.YEAR) + "-" +
           calendar_.get(Calendar.DAY_OF_YEAR) + "-" +createCurrentTimeStamp();
  }


  /**
   *  Creates a timestamp for the current time in the form of 'hour + "-" + min
   *  + "-" + sec + "-" + millis'.
   *
   * @return    The CurrentTimeStamp value.
   */
  public static String createCurrentTimeStamp()
  {
    String value = "";
    Calendar calendar_ = Calendar.getInstance();
    int currMillis = calendar_.get(calendar_.MILLISECOND);
    String millis = String.valueOf(currMillis);
    if (currMillis < 10)
    {
      millis = "00" + currMillis;
    }
    else if (currMillis < 100)
    {
      millis = "0" + currMillis;
    }
    int currSec = calendar_.get(calendar_.SECOND);
    String sec = String.valueOf(currSec);
    if (currSec < 10)
    {
      sec = "0" + currSec;
    }
    int currMin = calendar_.get(calendar_.MINUTE);
    String min = String.valueOf(currMin);
    if (currMin < 10)
    {
      min = "0" + currMin;
    }
    int currHr = calendar_.get(calendar_.HOUR_OF_DAY);
    String hour = String.valueOf(currHr);
    if (currHr < 10)
    {
      hour = "0" + currHr;
    }

    return (String) hour + "-" + min + "-" + sec + "-" + millis;
  }


  /**
   *  Creates a Timer timestamp from the current time to the passed startTime
   *  in the form of <BR>
   * 'hour + "-" + min + "-" + sec + "-" + millis'.
   *
   * THIS METHOD IS NOT COMPLETED. IT DOES NOT WORK YET.
   *
   * @return    The Timer Timestamp value.
   */
  public static String createTimerTimeStamp(int startTimeMillis)
  {
    String value = "";
    Calendar calendar_ = Calendar.getInstance();
    int currMillis = calendar_.get(calendar_.MILLISECOND) - startTimeMillis;
    String millis = String.valueOf(currMillis);
    int currSec = calendar_.get(calendar_.SECOND);
    String sec = String.valueOf(currSec);
    int currMin = calendar_.get(calendar_.MINUTE);
    String min = String.valueOf(currMin);
    int currHr = calendar_.get(calendar_.HOUR_OF_DAY);
    String hour = String.valueOf(currHr);
     if (currMillis < 10)
    {
      millis = "00" + currMillis;
    }
    else if (currMillis < 100)
    {
      millis = "0" + currMillis;
    }
   if (currSec < 10)
    {
      sec = "0" + currSec;
    }
    if (currMin < 10)
    {
      min = "0" + currMin;
    }
    if (currHr < 10)
    {
      hour = "0" + currHr;
    }

    return (String) hour + "-" + min + "-" + sec + "-" + millis;
  }


  /**
   *  Returns the calling classes name.
   @return the calling methods name.
   */
  public static String getCurrentClassName()
  {
   Throwable t = new Throwable();
   StackTraceElement[] es = t.getStackTrace();
   StackTraceElement e = es[1];
   return e.getClassName();
   //return e.getLineNumber();
   //return e.getMethodName();
  }


  /**
   *  Returns the calling methods name.
   @return the calling methods name.
   */
  public static String getCurrentMethodName()
  {
   Throwable t = new Throwable();
   StackTraceElement[] es = t.getStackTrace();
   StackTraceElement e = es[1];
   //return e.getClassName();
   //return e.getLineNumber();
   return e.getMethodName();
  }


  /**
   *  A simple String token replacement routine. Replaces all occurences of the
   *  token parameter with the replacement value in the passed in sentence
   *  parameter.
   *
   * @param  sentence     The String to perform the token replacement on
   * @param  token        the token String to seartch for and replace
   * @param  replacement  the tokens replacement value
   * @return              The new token replaced string
   */
  public static String tokenReplace(String sentence,
      String token,
      String replacement)
  {
    initUtil();
    final String methodName = CLASSNAME + ": tokenReplace";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }

    /*
    int a = 0;
    String retVal = "";
    while ((a = sentence.indexOf(token)) > -1)
    {
      retVal += sentence.substring(0, a) + replacement;
      sentence = sentence.substring(a + token.length());

    }

    retVal += sentence;
    */
    if (log_ != null)
    {
      log_.endMethod();
    }

    return sentence.replace(token,replacement);
  }


  /**
   *  Recursively deletes all the files in the spec'd directory and
   *  subdirectories, and then removes the dir.
   *
   * @param  fileName  The filename of the directory to delete.
   */
  public static boolean removeDir(String fileName)
  {
    initUtil();
    boolean retVal = false;
    File dirToDel = initDirFile(fileName);
    if (dirToDel != null)
    {
      String[] files = dirToDel.list();
      File tempFile;

      //loop through all the files in the dir DELETING them
      for (int i = 0; i < files.length; i++)
      {
        tempFile = new File(fileName + File.separator + files[i]);
        if (tempFile.isDirectory())
        {
          // recurse on the subdirectory
          removeDir(fileName + File.separator + files[i]);
        }
        else
        {
          // Delete all the files
          /* Java 7 only Code
          try
          {
            retVal = java.nio.file.Files.deleteIfExists(tempFile.toPath());
          }
          catch(Exception ex)
          {
            //System.out.println( );
            //ex.printStackTrace();
          }
          */
          retVal = tempFile.delete();
          //System.out.println((retVal?" Success":" Failed"));
        }
      }
      retVal = dirToDel.delete();
    }
    return retVal;
  }


  /**
   *  Deletes a file.
   *
   * @param  fileName  The filename to delete.
   */
  public static boolean removeFile(String fileName)
  {
    initUtil();
    boolean retVal = false;
    if (fileName != null)
    {
      File tempFile = new File(fileName);

      if (tempFile != null && tempFile.exists())
      {
        /* Java 7 only Code
        //System.out.print( "Attempting to delete filename: "+fileName);
        try
        {
          retVal = java.nio.file.Files.deleteIfExists(tempFile.toPath());
        }
        catch(Exception ex)
        {
          System.out.println( );
          ex.printStackTrace();
        }
        */
        retVal = tempFile.delete();
        System.out.println((retVal?" Success":" Failed"));
      }
    }
    return retVal;
  }


  /**
   *  Deletes all files in the spec'd dir that are older than the spec'd
   *  number of days.
   *
   * @param  dirName  The directory to parse for files to delete.
   * @param  numDays   The age of the files to delete.
   * @param  recurse   Do the removal recursively.
   */
  public static boolean removeOldFiles(String dirName,
                                       int numDays,
                                       boolean recurse)
  {
    initUtil();
    boolean retVal = false;
    final String methodName = CLASSNAME + ": removeOldFiles()";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    File dirFile = new File(dirName);

    if (dirFile.isDirectory() && dirFile.canRead())
    {
      String[] waste = dirFile.list();
      File tempFile = null;
      for (int i = 0; i < waste.length; i++)
      {
        tempFile = new File(dirName + File.separator + waste[i]);
        if (tempFile != null && !tempFile.isDirectory())
        {
          // if file is older than numDays... delete it
          long fileAge = tempFile.lastModified();
          Calendar rightNow = Calendar.getInstance();
          long rightNowInMillis = rightNow.getTimeInMillis();
          long numDaysInMillis = (new java.lang.Integer(numDays)).longValue() *
                                 24l * 60l * 60l * 1000l;
          if (rightNowInMillis - fileAge > numDaysInMillis)
          {
            //delete the file
            System.out.println("Deleting file "+ tempFile.getPath());
            tempFile.delete();
          }
        }
        else if (tempFile != null && recurse)
        {
          removeOldFiles(dirName + File.separator + waste[i], numDays, recurse);
        }
      }
    }

    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Obtains the bytes of data contained in all files in this dir
   *  (and subdirs).
   *
   * @param  fileName  The filename of the directory .
   *
   * @return the size of the dir in bytes.
   */
  public static long dirSizeOld(String fileName, boolean recurseSubdirs)
  {
    initUtil();
    long retVal = 0L;
    File dirToCalc = initDirFile(fileName);

    if (dirToCalc != null)
    {
      String[] files = dirToCalc.list();
      File tempFile;

      //loop through all the files in the dir
      if (files != null)
      {
        for (int i = 0; i < files.length; i++)
        {
          tempFile = new File(fileName + File.separator + files[i]);
          if (tempFile.isDirectory() && recurseSubdirs)
          {
            // recurse on the subdirectory
            retVal += dirSize(fileName + File.separator + files[i], true);
          }
          else
          {
            // add its size
            retVal += tempFile.length();
          }
        }
      }
      else
        log_.minor("Problem reading Directory "+fileName);
    }
    return retVal;
  }


  /**
   *  Obtains the bytes of data contained in all files in this dir
   *  (and subdirs).
   *
   * @param  fileName  The filename of the directory .
   *
   * @return the size of the dir in bytes.
   */
  public static long dirSize(String fileName, boolean recurseSubdirs)
  {
    initUtil();
    long retVal = 0L;
    File dirToCalc = initDirFile(fileName);
     String fileDir;
     String dirName;
    if(fileName.lastIndexOf(SYSTEM_FILE_SEPERATOR )>-1)
    {
      fileDir = fileName.substring(0, fileName.lastIndexOf(SYSTEM_FILE_SEPERATOR ));
      dirName = fileName.substring(fileName.lastIndexOf(SYSTEM_FILE_SEPERATOR )+1).trim();
    }
    else
    {
      fileDir = ".";
      dirName = fileName.trim();
    }

    if (dirToCalc != null)
    {
      String[] files = dirToCalc.list();
      File tempFile;

      try
      {
        java.nio.file.Path startPath = java.nio.file.FileSystems.getDefault().getPath(fileDir, dirName);
        final java.util.concurrent.atomic.AtomicLong size = new java.util.concurrent.atomic.AtomicLong(0);

        //loop through all the files in the dir
        if (files != null)
        {
          for (int i = 0; i < files.length; i++)
          {
            tempFile = new File(fileName + File.separator + files[i]);
            if (tempFile.isDirectory() && recurseSubdirs)
            {
              // recurse on the subdirectory
              fileDir = fileName;
              dirName = files[i];
              startPath = java.nio.file.FileSystems.getDefault().getPath(fileDir, dirName);
              size.addAndGet(java.nio.file.Files.size(startPath));
            }
            else
            {
              // add its size
              size.addAndGet(tempFile.length());
            }
          }
        }
        else
          log_.minor("Problem reading Directory "+fileName);

        retVal = size.get();
      }
      catch (java.nio.file.InvalidPathException invPathEx)
      {
        log_.minor("Problem reading Directory "+fileName);
        log_.minor("                  fileDir "+fileDir);
        log_.minor("                  dirName "+dirName);
      }
      catch (IOException invPathEx)
      {
        log_.minor("IOException reading   Dir "+fileName);
        log_.minor("                  fileDir "+fileDir);
        log_.minor("                  dirName "+dirName);
      }
    }
    return retVal;
  }


  /**
   *  Using the new NIO classes, obtains the bytes of data contained in all files in this dir
   *  (and subdirs).
   *  Implements <a href="https://stackoverflow.com/questions/7255592/get-file-directory-size-using-java-7-new-io">https://stackoverflow.com/questions/7255592/get-file-directory-size-using-java-7-new-io</a>
   *
   * @param  fileName  The filename of the directory .
   * @param  recurseSubdirs  include the subDirs in the result.
   *
   * @return the size of the dir in bytes.
   */
  public static long dirSize2(String fileName, boolean recurseSubdirs)
  {
    initUtil();
    long retVal = 0L;
    if(fileName.endsWith(SYSTEM_FILE_SEPERATOR)) fileName=fileName.substring(0, fileName.lastIndexOf(SYSTEM_FILE_SEPERATOR ));
    final String fileDir;
    final String dirName;
    if(fileName.lastIndexOf(SYSTEM_FILE_SEPERATOR )>-1)
    {
      fileDir = fileName.substring(0, fileName.lastIndexOf(SYSTEM_FILE_SEPERATOR ));
      dirName = fileName.substring(fileName.lastIndexOf(SYSTEM_FILE_SEPERATOR )+1).trim();
    }
    else
    {
      fileDir = ".";
      dirName = fileName.trim();
    }

    try
    {
      java.nio.file.Path startPath = java.nio.file.FileSystems.getDefault().getPath(fileDir, dirName);
      final java.util.concurrent.atomic.AtomicLong size = new java.util.concurrent.atomic.AtomicLong(0);

      System.out.println("        --> "+startPath.toString() +" ("+java.nio.file.Files.size(startPath)+")");
      size.addAndGet(java.nio.file.Files.size(startPath));
      //retVal += java.nio.file.Files.size(startPath);
      if(true && recurseSubdirs)
      {
        //System.out.println("      walkFileTree:"+fileDir+" , "+dirName);
        java.nio.file.Files.walkFileTree(startPath,
                                         new java.nio.file.SimpleFileVisitor<java.nio.file.Path>() {
            long totalSize = 0L;
            long fSize = 0L;
            @Override
            public java.nio.file.FileVisitResult visitFile(java.nio.file.Path filePath,
                                                           java.nio.file.attribute.BasicFileAttributes attrs) throws IOException {
                //size.addAndGet(attrs.size());
                fSize = java.nio.file.Files.size(filePath);
                //System.out.println("           > "+filePath.toString() +" ("+fSize+")");
                size.addAndGet(fSize);
                totalSize+=fSize;
                return java.nio.file.FileVisitResult.CONTINUE;
            }

            @Override
            public java.nio.file.FileVisitResult visitFileFailed(java.nio.file.Path filePath, IOException exc) throws IOException {
                // Skip folders that can't be traversed
                System.out.println("skipped: " + filePath + "\n      e=" + exc);
                exc.printStackTrace();
                //log_.minor("Problem reading Directory "+fileName);
                log_.minor("                  fileDir "+fileDir);
                log_.minor("                  dirName "+dirName);
                return java.nio.file.FileVisitResult.CONTINUE;
            }
        });
      }

      retVal = size.get();
    }
    catch (java.nio.file.InvalidPathException invPathEx)
    {
      log_.minor("Problem reading Directory "+fileName);
      log_.minor("                  fileDir "+fileDir);
      log_.minor("                  dirName "+dirName);
    }
    catch (IOException invPathEx)
    {
      log_.minor("IOException reading   Dir "+fileName);
      log_.minor("                  fileDir "+fileDir);
      log_.minor("                  dirName "+dirName);
    }

    //System.out.println("      dirSize2="+retVal);
    return retVal;
  }


  /**
   * Helper method to copy a file
   *
   * @param from the from filename
   * @param to the to filename
   **/
  public static void copyFile(String from, String to) throws IOException
  {
    File newFile = new File(to);
    if (newFile != null && newFile.exists())
      newFile.delete();
    (FileUtils.newFileUtils()).copyFile(from, to);
  }


  /**
   *  Token replace method for a given filename (NO recursion) and then saves the file with the
   *  swapped tokens. If you don't want to overwrite the original file make a
   *  copy 1st and then call this method on the copy.
   *
   * @param  file     The file(name) to act on
   * @param  token    The search token (that will get replaced)
   * @param  value    The replacement string.
   */
  public static void tokenReplaceInFile(String file, String token, String value)
  {
    tokenReplaceInFile( file,  token,  value, false);
  }


  /**
   *  Token replace method for a given filename (and optional recusion into subdirs) and then saves the file with the
   *  swapped tokens. If you don't want to overwrite the original file make a
   *  copy 1st and then call this method on the copy.
   *
   * @param  file     The file(name) to act on
   * @param  token    The search token (that will get replaced)
   * @param  value    The replacement string.
   */
  public static void tokenReplaceInFile(String file, String token, String value, boolean recurseSubdirs)
  {
    //boolean recurseSubdirs = true;
    // System.out.println("INTO tokenReplaceInFile("+file+", "+ token+", "+ value+", "+ recurseSubdirs+")");

    if (file!=null && !file.equals(""))
    {
      File rootFile = new File(file);
      //System.out.print(".");
      if( rootFile != null && !rootFile.isDirectory() && rootFile.canRead() )
      {
        Replace replace = new Replace();
        replace.setProject(new org.apache.tools.ant.Project());
        replace.setFile(rootFile);
        replace.setToken(token);
        replace.setValue(value);
        replace.execute();
        //System.out.println("~");
      }
      else if (rootFile != null && rootFile.isDirectory() && rootFile.canRead() )
      {
        if (recurseSubdirs)
        {
          System.out.println("Recursing into "+rootFile);
          String[] files = rootFile.list();
          File tempFile;
          //if ( verbose )
          //{
          //  System.out.println("Recursing into "+filename);
          //}

          //loop through all the files in the dir
          for (int i = 0; files != null && i < files.length; i++)
          {
            System.out.println("    ... S&R "+rootFile.toString()+SYSTEM_FILE_SEPERATOR+files[i]);
            tokenReplaceInFile(rootFile.toString()+SYSTEM_FILE_SEPERATOR+files[i],  token,  value, recurseSubdirs);
          }
        }
      }
    }
    else
      System.out.println("    File is null - '"+(file!=null?file:"NULL")+"'");
  }// -- tokenReplaceInFile()


  /**
   * Abstracts the compressing of a file with zip format - simly takes the file and wraps it whole into a zip file.
   *
   * @param s is the String to writeout
   * @param inFilename is the file name of the file to write the String into
   * @return if success, the full pathed filename is returned else null (default is infilename with the extension, after the last period, replaced with 'zip'.
   **/
  public static String compressFileWithZip(String inFilename)
  {
    return compressFileWithZip(inFilename,
                                (inFilename.substring(inFilename.lastIndexOf(".")+1).equalsIgnoreCase("kml")
                                  ? inFilename.substring(0,inFilename.lastIndexOf("."))+".kmz"
                                  : inFilename.substring(0,inFilename.lastIndexOf("."))+".zip"
                                 )
                               );
  }


  /**
   * Abstracts the compressing of a file with zip format - simly takes the file and wraps it whole into a zip file.
   *
   * @param inFilenames is the input file to zip up
   * @param zipFilename is the file name of the resulting zipfile
   * @return if success, the full pathed filename is returned else null
   **/
  public static String compressFileWithZip(String inFilename, String zipFilename)
  {
    String retVal = null;
    byte[] buffer = new byte[1024];
    if (zipFilename==null || zipFilename.equals(""))
      zipFilename = inFilename.substring(0,inFilename.lastIndexOf("."))+".zip";


    File tempFile = new File(inFilename);

    if (tempFile != null && !tempFile.isDirectory() && tempFile.canRead())
      try
      {
        FileOutputStream fos = new FileOutputStream(zipFilename);
        ZipOutputStream zos = new ZipOutputStream(fos);
        ZipEntry ze= new ZipEntry(inFilename);
        zos.putNextEntry(ze);
        FileInputStream in = new FileInputStream(inFilename);

        int len;
        while ((len = in.read(buffer)) > 0)
        {
          zos.write(buffer, 0, len);
        }

        in.close();
        //in.finalize();
        in = null;
        //tempFile.finalize();
        tempFile = null;
        zos.closeEntry();

        //remember close it
        zos.close();
        System.gc();
        retVal = zipFilename;
        //System.out.println("Done");

      }
      catch(IOException ex)
      {
         ex.printStackTrace();
      }

    return  retVal;
  }


  /**
   *  Wrapper method to accept a dir or individual file in the passed in File
   *  object AND then calls the method that writes the passed file/dir to this
   *  MultiZip instances zip output stream. This is a recursive function. If the
   *  passed File object is a file then it calls the function to write to zip
   *  output stream. If it is a directory it gets the list of file objects in
   *  the child directory and recurses on them.
   *
   * @param  fo  The File object to zip up (can be an actual file or dir).
   * @return     the new length in bytes of the zipped file
   */
  public static long recursiveBzip2(File fo)
  {
    //final String methodName = className_ + ": recursiveBzip2(File)";
    //logger_.debug("Entering " + methodName);
    long retVal = 0L;
    /**  The collection of filenames that actually got comp'd. */
    Vector compressedFilenames = new Vector();

    String fullFilename = fo.getAbsolutePath().trim();
    if (!fo.isDirectory())
    {
      //logger_.info("Bzip2ing "+fullFilename);
        StringBuffer outLocation = new StringBuffer();
        if (zippedOutputLocation_ != null)
        {
          // use the spec'd location
          String fileSep = System.getProperty("file.separator");
          outLocation.append(zippedOutputLocation_);
          if (!zippedOutputLocation_.endsWith(fileSep) &&
              !fullFilename.startsWith(fileSep))
          {
            outLocation.append(fileSep);
          }
          outLocation.append(fullFilename);
          outLocation.append(".bz2");
          //logger_.info("Bzip2ing " + fullFilename);
          //logger_.info("  to  " + outLocation.toString());
          File outFile = new File(outLocation.toString());
          Util.ensureFolderExists(outFile.getParentFile());
          try
          {
            BZip.compress(fo, outFile, 9);
            compressedFilenames.add(outLocation.toString());
            retVal += outFile.length();
          }
          catch (java.lang.ArithmeticException mathEx)
          {
            //logger_.error("BZip2 ERROR: " + fullFilename);
            //logger_.error(mathEx.getMessage());
            errorFiles_.add(fullFilename);
          }
        }
        else
        {
          // zip it in place
          //logger_.info("Bzip2ing "+fullFilename);
          File outFile = new File(fullFilename + ".bz2");
          Util.ensureFolderExists(outFile.getParentFile());
          try
          {
            BZip.compress(fo, outFile, 9);
            compressedFilenames.add(fullFilename + ".bz2");
            retVal += outFile.length();
          }
          catch (java.lang.ArithmeticException mathEx)
          {
            //logger_.error("BZip2 ERROR: " + fullFilename);
            //logger_.error(mathEx.getMessage());
          }
        }
    }
    else
    {
        //logger_.info("Recursing " + fo.getPath());
        String srcFileNames[] = fo.list();
        for (int i = 0; i < srcFileNames.length; i++)
        {
          retVal += recursiveBzip2(new File(fullFilename +
                                            File.separator +
                                            srcFileNames[i]));
        }
    }

    //logger_.debug("Exiting " + methodName);
    return retVal;
  }


  /**
   * Abstracts the compressing of all files in a dir with zip format - simply takes the dirFiles and wraps it whole into a zip file.
   * IT DOES NOT keep the top level dirname. It acts on the files incside the dir.
   *
   * @param inDirName is the input dir to source the files from to zip up
   * @param zipFilename is the file name of the resulting zipfile
   * @return if success, the full pathed filename is returned else null
   **/
  public static String compressDirFilesWithZip(String inDirName, String zipFilename)
  {
    String retVal = null;
    byte[] buffer = new byte[1024];
    if (zipFilename==null || zipFilename.equals(""))
      zipFilename = inDirName+".zip";

    File tempFile = new File(inDirName);
    File currFileBuff = null;
    String currFileName = "";

    if (tempFile != null && tempFile.isDirectory() && tempFile.canRead())
      try
      {
        FileOutputStream fos = new FileOutputStream(zipFilename);
        ZipOutputStream zos = new ZipOutputStream(fos);

        // Loop through all files in Dir
        File[] dirFiles = new File(inDirName).listFiles();
        for (File currFile: dirFiles)
        {
          currFileBuff = currFile;
          currFileName = currFile.getName();

          if (!currFile.isDirectory())
          {
            ZipEntry ze= new ZipEntry(currFileName);
            //System.out.println("Adding file : " + currFile.getName());
            zos.putNextEntry(ze);
            FileInputStream in = new FileInputStream(currFile);

            int len;
            while ((len = in.read(buffer)) > 0)
            {
              zos.write(buffer, 0, len);
            }

            in.close();
            //in.finalize();
            in = null;
            //tempFile.finalize();
          }
          else
          {
            //System.out.println("  Calling addDirToArchive: " + currFile.getName()+ " , "+
            //                   currFile.getAbsolutePath().substring(0,currFile.getAbsolutePath().indexOf(currFile.getName())));
            addDirToArchive(zos, currFile,
                               currFile.getAbsolutePath().substring(0,currFile.getAbsolutePath().indexOf(currFile.getName())));
          }
          tempFile = null;
          zos.closeEntry();
        }

        //remember close it
        zos.close();
        System.gc();
        retVal = zipFilename;
        //System.out.println("Done");

      }
      catch(IOException ex)
      {
        System.err.println("compressDirFilesWithZip error: \n"+
                           "    inDirName="+inDirName+"\n"+
                           "    zipFilename="+zipFilename+"\n"+
                           "    currFileName="+currFileName+"\n");
         ex.printStackTrace();
      }

    return  retVal;
  }


  /**
    * Simple recursive method that takes a Directory File and pumps its files into the passed in zip.<br />
    * <b>It adds the files within 'srcFile' to the zip.</b><br />
    * You also pass it the root path that will be chopped off the front of the embedded file paths
    * so everything ends up in a nice root of the zip file.<br />
    * For example: <pre>
    * String inDirName = "c:\Users\JoeBlo\Docs\work\ProjectA";
    * File dirFile = new File(inDirName);
    *
    * String zipFilename = "ProjectA_files.zip";
    * FileOutputStream fos = new FileOutputStream(zipFilename);
    * ZipOutputStream zos = new ZipOutputStream(fos);
    *
    * // get the root part of the path to the file to zip up
    * // gets "c:\Users\JoeBlo\Docs\work"
    * String rootDirStr = dirFile.getAbsolutePath().substring(0,dirFile.getAbsolutePath().indexOf(dirFile.getName()));
    *
    * // create a zip with the files within 'dirFile' inside it
    * addDirToArchive(zos, dirFile, rootDirStr);
    * zos.close();
    * </pre>
    *
    * @param zos is the already created ZipOutputStream to add to
    * @param srcFile is the Directory File to zip up its contained files
    * @param rootDir the root path that will be chopped off the front of the embedded file paths so everything ends up in a nice root of the zip file.
    **/
  private static void addDirToArchive(ZipOutputStream zos, File srcFile, String rootDir) throws IOException
  {

    File[] files = srcFile.listFiles();

    for (int i = 0; i < files.length; i++)
    {
      // if the file is directory, use recursion
      if (files[i].isDirectory())
      {
          //System.out.println("Adding directory: " + files[i].getName());
          addDirToArchive(zos, files[i], rootDir);
          continue;
      }

      //try
      //{
        //System.out.println("           Adding file: " + files[i].getAbsolutePath() +
        //                   " as "+ files[i].getAbsolutePath().substring(rootDir.length()));
        // create byte buffer
        byte[] buffer = new byte[1024];

        FileInputStream fis = new FileInputStream(files[i]);

        // Zip files should use '/' as the file/directory seperator.
        // Google Earth (kmz) will not find sub dirs if using a '\'
        zos.putNextEntry(new ZipEntry(tokenReplace(files[i].getAbsolutePath().substring(rootDir.length()),"\\","/")));

        int length;
        while ((length = fis.read(buffer)) > 0)
        {
            zos.write(buffer, 0, length);
        }

        zos.closeEntry();
        // close the InputStream
        fis.close();

      //}
      //catch (IOException ioe)
      //{
      //    System.out.println("IOException :" + ioe);
      //}
    }
  }  //addDirToArchive


   /**
   * Abstracts the loading of a resource image file from ca.bc.webarts.resources.images as an icon.
   *
   * @param name is the file name of the file to read
   **/
  public static Icon loadIcon(String name)
  {
    return loadIcon("ca.bc.webarts.resources.images", name);
  }

   /**
   * Abstracts the loading of a resource image file as an icon.
   *
   * @param name is the file name of the file to read
   **/
  public static Icon loadIcon(String resourcePackageName, String name)
  {
    java.net.URL imgURL = Util.class.getResource("/"+tokenReplace(resourcePackageName,".","/")+"/" + name);
    if (imgURL != null)
    {
        return new ImageIcon(imgURL);
    }
    else
    {
        System.err.println("Unable to find " + "/"+tokenReplace(resourcePackageName,".","/")+"/" +name);
        return null;
    }
  }


  /**
   * Abstracts the writing of an InputSteam to a file.
   *
   * @param fileName is the file name of the file to write the String into
   * @return if success.. the full pathed filename is returned else null
   **/
  public static String writeStringToFile(java.io.InputStream inputStream, String fileName)
  {
    String retVal = fileName;
    String props = "java.io.tmpdir";
    String tempDir = System.getProperty("java.io.tmpdir");
    try
    {
      // write the inputStream to a FileOutputStream
      OutputStream out = new FileOutputStream(new File(fileName));

      int read = 0;
      byte[] bytes = new byte[1024];
      while ((read = inputStream.read(bytes)) != -1)
      {
        out.write(bytes, 0, read);
      }
      inputStream.close();
      out.flush();

      System.out.println("New file created!");
    }
    catch (IOException e)
    {
      System.out.println(e.getMessage());
      retVal = "";
    }
    return retVal;
  }


  /**
   * Abstracts the writing of an InputSteam to a file.
   *
   * @param fileName is the file name of the file to write the String into
   * @return if success.. the full pathed filename is returned else null
   **/
  public static String writeStringToFile(java.io.ByteArrayInputStream inputStream, String fileName)
  {
    String retVal = fileName;
    String props = "java.io.tmpdir";
    String tempDir = System.getProperty("java.io.tmpdir");
    try
    {
      // write the inputStream to a FileOutputStream
      OutputStream out = new FileOutputStream(new File(fileName));

      int read = 0;
      byte[] bytes = new byte[1024];
      while ((read = inputStream.read(bytes)) != -1)
      {
        out.write(bytes, 0, read);
      }
      inputStream.close();
      out.flush();

      System.out.println("New file created!");
    }
    catch (IOException e)
    {
      System.out.println(e.getMessage());
      retVal = "";
    }
    return retVal;
  }


   /**
   * Abstracts the appending of string to a file and creates it if not already there.
   * see http://docs.oracle.com/javase/7/docs/api/java/nio/file/StandardOpenOption.html
   *
   * @param s is the String to writeout
   * @param fileName is the file name of the file to write the String into
   * @return if success.. the full pathed filename is returned else null
   **/
  public static String appendStringToFile(String s, String fileName)
  {
    String retVal = null;
    PrintWriter out = null;
    BufferedWriter bufWriter = null;

    try
    {
        bufWriter =
            Files.newBufferedWriter(
                Paths.get(fileName),
                Charset.forName("UTF8"),
                StandardOpenOption.WRITE,
                StandardOpenOption.APPEND,
                StandardOpenOption.CREATE);
        out = new PrintWriter(bufWriter, true);
    }
    catch(IOException e)
    {
        //Oh, no! Failed to create PrintWriter
    }

    if (out!=null)
    {
      try
      {
        //After successful creation of PrintWriter
        out.print(s);
        retVal = fileName;
      }
      catch( Exception e )
      {
         // File writing/opening failed at some stage.
      }
      finally
      {
         try
         {
            if( out != null )
            {
               out.close(); // Will close bw and fw too
            }
            else if( bufWriter != null )
            {
               bufWriter.close(); // Will close fw too
            }
            else
            {
               // Oh boy did it fail hard! :3
            }
         }
         catch( IOException e )
         {
            // Closing the file writers failed for some obscure reason
         }
      }
    }
    return retVal;
  }


   /**
   * Abstracts the writing of string to a file.
   *
   * @param s is the String to writeout
   * @param fileName is the file name of the file to write the String into
   * @return if success.. the full pathed filename is returned else null
   **/
  public static String writeStringToFile(String s, String fileName)
  {return  writeStringToFile( s,  fileName, false);}


  /**
   * Abstracts the writing of string to a (zip) file (Zip NOT IMPLEMENTED YET).
   *
   * @param s is the String to writeout
   * @param fileName is the file name of the file to write the String into
   * @param zipCompress boolean fall to compress with zip compression
   * @return if success.. the full pathed filename is returned else null
   **/
  public static String writeStringToFile(String s, String fileName, boolean zipCompress)
  {
    String retVal = fileName;

    try
    {
      // FileWriter was not closing the stream
      /*
      FileWriter f = new FileWriter(fileName);
      f.write(s);
      f.flush();
      f.close();
      f = null;
      */
      FileOutputStream fos = new FileOutputStream(fileName);
      byte[] strBytes = s.getBytes();
      fos.write(strBytes);
      fos.flush();
      fos.close();
      fos = null;
      System.gc(); // this is required because a bug in Java won't realease
    }
    catch (IOException ioEx)
    {
      System.out.println("\nERROR Writing file: "+fileName);
      retVal = null;
    }

    return retVal;
  }


  /**
   * Abstracts the reading of a file and returns the contents as a String.
   *
   * @param fileName is the file naem to read into a String
   * @return the Text file contents as a String
   **/
  public static String readFileToString(String fileName)
  {
    String stringLine;
    BufferedReader in;
    StringBuffer stringOut = new StringBuffer("");
    try
    {
      in = new BufferedReader(new FileReader(fileName));
      while ((stringLine = in.readLine()) != null)
      {
        stringOut.append(stringLine);
        stringOut.append(SYSTEM_LINE_SEPERATOR);
      }
    }
    catch (FileNotFoundException fnfEx)
    {
      System.out.println("Cannot find file: "+fileName);
      stringOut = new StringBuffer("");
    }
    catch (IOException ioEx)
    {
      System.out.println("Error Reading File to String: "+fileName);
      stringOut = new StringBuffer("");
    }

    return stringOut.toString();
  }


      /**
   *  Searches the provided file for the search String.
   *
   * @param  searchStr      The searchString/regexp to search for.
   * @param  filename       The filename to search through.
   * @param  verbose        true will produce output to System.out just like the
   *                        UNIX find cmd
   *
   * @return an array of the matched lines
   */
  public static String [] searchInFile(String searchStr, String filename,
                                        boolean verbose)
  {
    initUtil();
    Vector <String>  retVal = new  Vector <String>();
    BufferedReader in;
    RE expression = null;
    String s;
    int regExFlags = RE.REG_ICASE;
    int numExtraBeforeLines = 2;
    String [] extraBeforeLines = new String [numExtraBeforeLines];
    int currLineNumber = 0;
    for (int i=0; i< numExtraBeforeLines ; i++)
      extraBeforeLines[i] = "";

    File rootFile = new File(filename);

    if (rootFile != null && !rootFile.isDirectory())
    {
      if(rootFile.canRead())
      {
        try
        {
          in = new BufferedReader(new FileReader(filename));
          currLineNumber = 0;
          while ((s = in.readLine()) != null)
          {
            currLineNumber++;
            expression = new RE(searchStr, regExFlags);
            if (expression.getMatch(s)!=null)
            {
              if ( verbose )
              {
                System.out.println("FILE: "+filename);
                for (int i=0; i< numExtraBeforeLines ; i++)
                  System.out.println("  "+currLineNumber+extraBeforeLines[i]);
                System.out.println("  "+currLineNumber + "  "+s);
                System.out.println();
              }
              retVal.addElement(s);
            }
            for (int i=0; i< numExtraBeforeLines-1 ; i++)
              extraBeforeLines[i] = extraBeforeLines[i+1];
            extraBeforeLines[numExtraBeforeLines-1] = s;
          }
          in.close();
        }
        catch (REException reEx)
        {
          reEx.printStackTrace();
        }
        catch (FileNotFoundException fEx)
        {
          fEx.printStackTrace();
        }
        catch (IOException ioEx)
        {
          ioEx.printStackTrace();
        }

      }
    }
    String [] rets = new String [retVal.size()];

    for (int i=0; i < retVal.size(); i++)
    {
      rets[i] = (String) retVal.elementAt(i);
    }
    return rets;
  }


  /**
   *  Searches the provided file/directory (and subdirs) for the search String.
   *
   * @param  searchStr      The searchString/regexp to search for.
   * @param  filename       The filename/directoryName to search through.
   * @param  recurseSubdirs Flags if the sub-dirs are searched.
   * @param  fileRegExp     Flags if 'fileName' should be regarded as a regular
   *                        expression.
   * @param  verbose        true will produce output to System.out just like the
   *                        UNIX find cmd
   *
   * @return a hash of the full cannoical paths/and a Vector of the lineNumbers
   *                          in that file
   */
  public static Hashtable searchInFile(String searchStr, String filename,
                              boolean recurseSubdirs, boolean fileRegExp,
                              boolean verbose)
  {
    initUtil();
    Hashtable retVal = new Hashtable();
    Vector fileLineNumbers = new Vector();
    BufferedReader in;
    RE expression = null;
    String s;
    int regExFlags = RE.REG_ICASE;
    int numExtraBeforeLines = 2;
    String [] extraBeforeLines = new String [numExtraBeforeLines];
    String currFilename;
    int currLineNumber = 0;
    for (int i=0; i< numExtraBeforeLines ; i++)
      extraBeforeLines[i] = "";

    File rootFile = new File(filename);

    if (rootFile != null && !rootFile.isDirectory())
    {
      if(rootFile.canRead())
      {
        currFilename = filename;
        try
        {
          in = new BufferedReader(new FileReader(currFilename));
          fileLineNumbers.clear();
          currLineNumber = 0;
          while ((s = in.readLine()) != null)
          {
            currLineNumber++;
            expression = new RE(searchStr, regExFlags);
            if (expression.getMatch(s)!=null)
            {
              if ( verbose )
              {
                System.out.println("FILE: "+currFilename);
                for (int i=0; i< numExtraBeforeLines ; i++)
                  System.out.println("  "+currLineNumber+extraBeforeLines[i]);
                System.out.println("  "+currLineNumber + "  "+s);
                System.out.println();
              }
              fileLineNumbers.add(new Integer(currLineNumber));
            }
            for (int i=0; i< numExtraBeforeLines-1 ; i++)
              extraBeforeLines[i] = extraBeforeLines[i+1];
            extraBeforeLines[numExtraBeforeLines-1] = s;
          }
          in.close();
          if (fileLineNumbers.size() > 0)
            retVal.put(currFilename, fileLineNumbers.clone());
        }
        catch (REException reEx)
        {
          reEx.printStackTrace();
        }
        catch (FileNotFoundException fEx)
        {
          fEx.printStackTrace();
        }
        catch (IOException ioEx)
        {
          ioEx.printStackTrace();
        }
      }
    }
    else
    {
      // it is a directory so recurse on files if recursing flag is set
      if (recurseSubdirs)
      {
        String[] files = rootFile.list();
        File tempFile;
        //if ( verbose )
        //{
        //  System.out.println("Recursing into "+filename);
        //}

        //loop through all the files in the dir
        Hashtable recursedHash = null;
        for (int i = 0; files != null && i < files.length; i++)
        {
          recursedHash = null;
          recursedHash = searchInFile(searchStr,
                                      filename + File.separator + files[i],
                                      recurseSubdirs, fileRegExp, verbose);
          if (recursedHash != null ) retVal.putAll(recursedHash);
        }
      }
    }

    return retVal;
  }


  /**
   *  Searches the provided directory (and subdirs) for the requested file.
   *
   * @param  fileName       The filename/regexp to search for.
   * @param  directory      The filename of the directory to delete.
   * @param  recurseSubdirs Flags if the sub-dirs are searched.
   * @param  regExp         Flags if 'fileName' should be regarded as a regular
   *                        expression.
   * @param  verbose        true will produce output to System.out just like the
   *                        UNIX find cmd
   *
   * @return the full cannoical paths to the found files.
   */
  public static Vector findFile(String fileName, String directory,
                              boolean recurseSubdirs, boolean regExp, boolean verbose)
  {
    initUtil();
    final String methodName = CLASSNAME + ": findFile(" +
        fileName + " " + directory + " " + recurseSubdirs+ " " + regExp+ " " + verbose+ " )";
    if (log_ != null) log_.startMethod(methodName);
    Vector retVal = new Vector();
    File dirToSearch = initDirFile(directory);

    if (dirToSearch != null)
    {
      String[] files = dirToSearch.list();
      File tempFile;
      if ( files!= null) log_.debug("Searching "+files.length +" files&dirs");

      //loop through all the files in the dir
      for (int i = 0; files != null && i < files.length; i++)
      {
        tempFile = new File(directory + File.separator + files[i]);
        if (tempFile.isDirectory() && recurseSubdirs)
        {
          // recurse on the subdirectory
          retVal.addAll(findFile(fileName, directory + File.separator + files[i],
                             recurseSubdirs, regExp, verbose));
        }
        else if (!tempFile.isDirectory())
        {
          // does it match
          String absPath = tempFile.getAbsolutePath();
          log_.debug("Searching "+absPath);

          if (regExp)
          {
            try
            {
              RE expression = new RE(fileName);
              if (expression.isMatch(files[i]))
              {
                retVal.add(absPath);
                if (verbose) System.out.println(absPath);
              }
            }
            catch (REException reExp)
            {
              reExp.printStackTrace();
              break;
            }
          }
          else if (files[i].trim().indexOf(fileName) >= 0)
          {
            retVal.add(absPath);
            if (verbose)System.out.println(absPath);
          }
        }
      }
    }
    if (log_ != null) log_.endMethod(methodName);
    return retVal;
  }


  /**
   *  Initisalizes File only if it is directory.It is represented by the passed
   *  in String.
   *
   * @param  s  the directory name to init as a File
   * @return    An instatiated File object if the passed string is a dir, null
   *      if not
   */
  public static File initDirFile(String s)
  {
    initUtil();
    File retVal = null;
    File dirFile = new File(s);
    if (dirFile.isDirectory() && dirFile.canRead())
    {
      retVal = dirFile;
    }
    return retVal;
  }


public static String csvToJSON(String content, String separator){

    StringBuilder sb=new StringBuilder("[\n");

    String spacer = "  ";
    String csv = content;
    String csvValues[] = csv.split("\n");
    String header[]=csvValues[0].split("\\"+separator);

    for(int i=1;i<csvValues.length;i++)
    {
      sb.append(spacer).append("{").append("\n");
      String tmp[]=csvValues[i].split("\\"+separator);
      for(int j=0;j<tmp.length;j++)
      {
        sb.append(spacer).append(spacer).append("\"").append(header[j]).append("\":\"").append(tmp[j]).append("\"");
        if(j<tmp.length-1)
        {
          sb.append(",\n");
        }
        else
        {
          sb.append("\n");
        }
      }
      if(i<csvValues.length-1)
      {
        sb.append(spacer);
        sb.append("},\n");
      }
      else{
        sb.append(spacer);
        sb.append("}\n");
      }
    }

    sb.append("]");

    return sb.toString();
}


  /**
 * Renames files to a more URL friendly format.
 * <P>It goes through each file in the specified directory and renames them
 * using the spacesToCapsInFileName method of renaming.
 *
 * @see #spacesToCapsInFileName(String)
 * @see #dirFile
 **/
public static void spacesToCapsInDir(String dirName)
{
  spacesToCapsInDir(dirName, true);
}


/**
 * Renames files to a more URL friendly format.
 * <P>It goes through each file in the specified directory and renames them
 * using the spacesToCapsInFileName method of renaming.
 *
 * @see #spacesToCapsInFileName(String)
 * @see #dirFile
 **/
public static void spacesToCapsInDir(String dirName, boolean doUnderscores)
{
  spacesToCapsInDir( dirName,  doUnderscores, true);
}

/**
 * Renames files to a more URL friendly format.
 * <P>It goes through each file in the specified directory and renames them
 * using the spacesToCapsInFileName method of renaming.
 *
 * @see #spacesToCapsInFileName(String)
 * @see #dirFile
 **/
public static void spacesToCapsInDir(String dirName, boolean doUnderscores, boolean verboseOut)
{
  File dirFile = initDirFile(dirName);
  //verboseOut = false;
  if (dirFile !=null)
  {
    String newDirName = dirName;
    boolean succeeded = false;
    // check and rename the initial dir
    if (dirFile.toString().indexOf(" ") != -1 ||
        dirFile.toString().indexOf("_") != -1)
    {
      newDirName = spacesToCapsInString(dirFile.toString(), doUnderscores);
      if (verboseOut) System.out.println("Renaming: "+dirFile.toString()+" -> "+newDirName);
      //if (verboseOut) System.out.println("       "+dirFile.getAbsolutePath()+"   "+spacesToCapsInString(dirFile.toString(), true));
      succeeded = dirFile.renameTo(new File(newDirName));
    }
    if (true)
    {
      succeeded = false;
      dirFile = initDirFile(newDirName);
      if (dirFile != null &&
          dirFile.isDirectory() &&
          dirFile.canRead() &&
          newDirName  != null )
      {
        String [] fileName = dirFile.list();
        if (verboseOut) System.out.print("Formatting dir="+dirFile.toString());
        if (verboseOut) System.out.println("   It has "+fileName.length + " files.");
        File tempFile;
        for (int i=0;i< fileName.length;i++)
        {
          tempFile = new File(newDirName+File.separator+fileName[i]);

          // do a depth first file rename of the subdir files
          if (tempFile != null && tempFile.isDirectory())
            spacesToCapsInDir(tempFile.toString(), doUnderscores);
          String newName = spacesToCapsInString(fileName[i], doUnderscores);
          //if (verboseOut) System.out.println(fileName[i] +" .. " +newName);
          try
          {
            if (newName !="" && fileName[i].length() != newName.length())
            {
              //if (verboseOut) System.out.println(i+".1) "+tempFile.toString());
              //if (verboseOut) System.out.print(i+".2) "+newDirName+File.separator+newName);
              succeeded = tempFile.renameTo(
                new File(newDirName+File.separator+newName));
              if (succeeded)
                if (verboseOut) System.out.println("  succeeded.");
              else
                if (verboseOut) System.out.println("");
              File tempFile2 = new File(newDirName+File.separator+fileName[i]);
              if (tempFile2.exists() &&
                  tempFile.exists() &&
                  !newName.toUpperCase().equals(fileName[i].toUpperCase()))
              {
                tempFile2.delete();
              }
            }
          }
          catch (SecurityException ex)
          {
            System.err.println("SecurityException " + ex);
          }
          catch (NullPointerException ex)
          {
            System.err.println("NullPointerException " + ex);
          }
        } //loop
      }
    }
    else
    {
      System.err.println("Could not rename "+dirName +" to "+newDirName);
    }
  }
  else
    System.err.println("Problems initing  "+dirName );
}


/**
 * Removes any space chars ' ' from a filename and Capitalizes the next char.
 * <P><B>NOTE:</B> The file is expected to be in
 * the current working directorydirectory
 *
 * @param fName a string representing the file to perform the action
 * @return the new filename representation
 **/
public static String spacesToCapsInFileName(String fName)
{
  String newName = "";
  File tempFile;
  if (fName != null){
    tempFile = new File(USERDIR+File.separator+fName);
    if(!tempFile.isDirectory())
    {
      newName = spacesToCapsInString(fName);
    }
  }
  return newName;
}


/**
 * Removes any space chars ' ' from a String and Capitalizes the next char.
 *
 * @param fName a string  perform the action
 * @return the new representation
 **/
public static String spacesToCapsInString(String fName)
{
  return spacesToCapsInString(fName, false);
}


/**
 * Removes any space chars ' ' from a String and Capitalizes the next char.
 *
 * @param fName a string  perform the action
 * @param includeUnderscoreflag if  '_' are also removed
 * @return the new representation
 **/
public static String spacesToCapsInString(String fName, boolean includeUnderscore)
{
  initUtil();
  String newName = "";
  boolean space = false;
  for (int j=0; j< fName.length(); j++)
  {
    char newChar = fName.charAt(j);
    if (newChar == ' ' || (newChar == '_' && includeUnderscore))
    {
      // set the space flag so the next char can be cap'd
      space = true;
    }
    else
    {
      if (space) // was the last char a space???
      {
        newName += String.valueOf(Character.toUpperCase(newChar));
      }
      else
      {
        newName += String.valueOf(newChar);
      }
      space = false;
    }
  }
  return newName;
}

///opt/jetty/baseDir/webapps/tunes/WEB-INF/classes
/**
 * Takes a string and adds a space in front of any capitalized char.
 * Basically the reverse of the method spacesToCapsInString.
 *
 * @param fName a string  perform the action
 * @return the new representation
 **/
public static String capsToSpacesInString(String fName)
{
  initUtil();
  StringBuffer newName = new StringBuffer();
  char newChar;
  for (int j=0; j< fName.length(); j++)
  {
    newChar = fName.charAt(j);
    //System.out.println("char="+newChar + ((newChar=='(' || newChar=='[' || newChar=='{' || newChar=='<' || newChar=='&') ?" Yes":" No"));
    if (Character.isLetter(newChar))
    {
      if(Character.isUpperCase(newChar))
      {
        newName.append(" ");
      }
    }
    else if(newChar=='(' || newChar=='[' || newChar=='{' || newChar=='<' || newChar=='&')
      {
        newName.append(" ");
      }
    newName.append(String.valueOf(newChar));
  }
  return newName.toString();
}


/**
 * Takes a string and adds a space in front of any capitalized char.
 * Basically the reverse of the method spacesToCapsInString.
 *
 * @param fName a string  perform the action
 * @return the new representation
 **/
public static String capsToUndersInString(String fName)
{
  initUtil();
  StringBuffer newName = new StringBuffer();
  char newChar;
  for (int j=0; j< fName.length(); j++)
  {
    newChar = fName.charAt(j);
    if (Character.isLetter(newChar) && Character.isUpperCase(newChar))
    {
      newName.append("_");
    }
      newName.append(String.valueOf(newChar));
  }
  return newName.toString();
}


  /**
    * Gives you the rightmost number of chars in a string.
    *
    * @param value is the string to pull result from
    * @param numChars the number of chars to return from the right side of 'value'
    * @return a string holding the rightmost number of chars in the passed in String
    **/
  public static String right(String value, int numChars)
  {
    String retVal = value;
    if(value!=null && value.length()>= numChars) retVal = value.substring(value.length() - numChars);
    return retVal;
  }


  /**
    * Gives you the leftmost number of chars in a string.
    *
    * @param value is the string to pull result from
    * @param numChars the number of chars to return from the left side of 'value'
    * @return a string holding the leftmost number of chars in the passed in String
    **/
  public static String left(String value, int numChars)
  {
    String retVal = value;
    if(value!=null && value.length()>= numChars) retVal = value.substring(0,numChars);
    return retVal;
  }


  /**
   *  Searches the classpath for the specified filename and then returns the
   *  full path that is used for it.
   *
   * @param  filename  to look for in the classpath
   * @param  fallBack  if the file is not found in classpath
   * @return           the path description of the passed filename as found in
   *      the classpath.
   */
  public static String getFilePathFromClasspath(String filename, String fallBack)
  {
    initUtil();
    final String methodName = CLASSNAME +
        ": getFilePathFromClasspath(String, String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    String retVal = getFilePathFromClasspath(filename);
    //System.out.println("File In Classpath="+retVal);
    if (retVal == null || retVal.equals(""))
    {
      retVal = fallBack;
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    //System.out.println("File In Classpath="+retVal);
    return retVal;
  }


  /**
   *  Searches the classpath for the specified filename and then returns the
   *  full path that is used for it.
   *
   * @param  filename  the filename to look for
   * @return           the path description of the passed filename as found in
   *      the classpath.
   */
  public static String getFilePathFromClasspath(String filename)
  {
    initUtil();
    final String methodName = CLASSNAME + ": getFilePathFromClasspath";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    String retVal = "";
    String pathSep = System.getProperty("path.separator");
    if (CLASSPATH == null)
    {
      return "";
    }
    int fileIndex = CLASSPATH.indexOf(filename);
    if (log_ != null)
    {
      log_.debug("Searching the Classpath for " + filename +
          " " + fileIndex);
    }
    if (fileIndex >= 0)
    {
      int startSpot = 0;
      int nextSpot = CLASSPATH.indexOf(pathSep);
      // the fileName is in the classpath
      if (log_ != null)
      {
        log_.debug("Start Looking at (" + startSpot + "," + nextSpot + ")");
      }
      while ((nextSpot < fileIndex) && nextSpot != -1)
      {
        startSpot = nextSpot;
        nextSpot = CLASSPATH.indexOf(pathSep, startSpot + 1);
        if (log_ != null)
        {
          log_.debug(", (" + startSpot + "," + nextSpot + ")");
        }
      }
      if (startSpot <= 0)
      {
        startSpot = -1;
      }
      if (nextSpot <= 0)
      {
        nextSpot = CLASSPATH.length();
      }
      retVal = CLASSPATH.substring(startSpot + 1, nextSpot);
    }
    else
        if (log_ != null)
    {
      log_.minor(filename + " cannot be found in classpath.");
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  This method seeks out and returns the Parent Frame for a given component.
   *
   * @param  c  The Component to be used as the basis of the frame search
   * @return    Frame The Frame that eventually holds the giuven Component.
   */
  public static Frame getAncestorFrame(Component c) {
    Frame retVal = null;
    while ((c = c.getParent()) != null)
      if (c instanceof Frame) {
        retVal = (Frame) c;
      }
    return retVal;
  }


  /**
   *  Calls the User Interface Manager and sets the look and feel setting based
   *  on the parameter it is passed. Use the Class Contstants UTIL.METAL_LOOKANDFEEL, etc.
   *
   * @param  i   The new TheLookAndFeel value
   */
  public static void setTheLookAndFeel(short i, Component comp) {
    /* Force SwingSet to come up in the Cross Platform L&F */
    try {
      switch ((int)i){
        case METAL_LOOKANDFEEL:
          // If you want the Java L&F
          UIManager.setLookAndFeel(metalClassName);
          log_.debug("Setting the Java L&F");
          break;
        case WINDOZE_LOOKANDFEEL:
          // If you want the System L&F
          UIManager.setLookAndFeel(windowsClassName);//UIManager.getSystemLookAndFeelClassName());
          log_.debug("Setting the System L&F");
          break;
        case MOTIF_LOOKANDFEEL:
          // If you want the Motif L&F
          UIManager.setLookAndFeel(motifClassName);
          log_.debug("Setting the Motif L&F");
          break;
        case MAC_LOOKANDFEEL:
          // If you want the Mac L&F
          UIManager.setLookAndFeel(macClassName);
          log_.debug("Setting the Mac L&F");
          break;
        default:
          // defaults to Java L&F
          UIManager.setLookAndFeel(UIManager.getCrossPlatformLookAndFeelClassName());
          log_.debug("Setting the Java L&F");
      }
      SwingUtilities.updateComponentTreeUI(Util.getAncestorFrame(comp));
    }
    catch (Exception exc)
    {
      System.err.println("Error loading L&F: " + exc);
    }
  }


  /**
   *  Loads the requested Image filename from the specified jarfile.
   *
   * @param  imageFilename  the filename in the jarfile to use as the basis for
   *      the Image to retrieve.
   * @param  jarFilename    the jar file to look through for the image.
   * @return                Image the Image loaded from the filename spec'd as
   *      an imput param, It returns null if it cannot retrieve the Image.
   */
  public static Image loadImage(String imageFilename, String jarFilename)
  {
    initUtil();
    final String methodName = CLASSNAME + ": loadImage(String, String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    if (log_ != null)
    {
      log_.debug("Loading Imagename " + imageFilename);
    }
    Image retVal = (new ImageIcon(Util.class.getResource("/" + imageFilename))).
        getImage();
    /*
     *  String iconJarFileName = jarFilename; //getFilePathFromClasspath(jarFilename);
     *  if(log_!=null) log_.debug("Loading Imagename "+imageFilename+" from Jarfile "+jarFilename);
     *  InputStream in = null;
     *  JarEntry tempJarEntry = null;
     *  byte [] imageBytes;
     *  long imageFileSize = 0l;
     *  int bytesRead = 0;
     *  try
     *  {
     *  JarFile jar = new JarFile(iconJarFileName, false);
     *  tempJarEntry = jar.getJarEntry(imageFilename);
     *  in = jar.getInputStream(tempJarEntry);
     *  imageFileSize = tempJarEntry.getSize();
     *  imageBytes = new byte[(int)imageFileSize];
     *  for (int j=0;j<imageFileSize;j++)
     *  imageBytes[j] = new Integer(in.read()).byteValue();
     *  if(log_!=null) log_.debug("Loaded "+imageFileSize+" Bytes.");
     *  retVal = (Toolkit.getDefaultToolkit()).createImage(imageBytes);
     *  }
     *  catch (NullPointerException fEx)
     *  {
     *  System.out.println("No graphicJarEntry NullPointerException " +
     *  imageFilename);
     *  }
     *  catch (FileNotFoundException fEx)
     *  {
     *  System.out.println("graphic FileNotFoundException " +imageFilename);
     *  }
     *  catch (IOException ioEx)
     *  {
     *  System.out.println("graphic FileNotFoundException " +imageFilename);
     *  }
     *  catch (SecurityException secEx)
     *  {
     *  System.out.println("graphic SecurityException " +imageFilename);
     *  }
     */
    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Loads the requested Image filename from the classpath.
   *
   * @param  imageFilename  the filename in the jarfile to use as the basis for
   *      the Image to retrieve.
   * @return                Image the Image loaded from the filename spec'd as
   *      an imput param, It returns null if it cannot retrieve the Image.
   */
  public static Image loadImage(String imageFilename)
  {
    initUtil();
    final String methodName = CLASSNAME + ": loadImage()";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    if (log_ != null)
    {
      log_.debug("Loading Imagename " + imageFilename);
    }
    //System.out.println("Loading Imagename "+imageFilename);
    URL resourceUrl = Util.class.getResource(imageFilename);
    Image retVal = null;
    if (resourceUrl != null)
    {
      retVal = (new ImageIcon(resourceUrl)).getImage();
    }
    else
        if (log_ != null)
    {
      log_.minor("DID NOT Get the Resource URL for :" + imageFilename);
    }

    if (retVal == null)
    {
      if (log_ != null)
      {
        log_.minor("Could NOT create Image for " + imageFilename);
      }
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  A method to simply abstract the Try/Catch required to put the current
   *  thread to sleep for the specified time in ms.
   *
   * @param  waitTime  the sleep time in milli seconds (ms).
   * @return           boolean value specifying if the sleep completed (true) or
   *      was interupted (false).
   */
  public static boolean sleep(long waitTime)
  {
    final String methodName = CLASSNAME + ": sleep(Long)";
    if (log_ != null)
    {
      //log_.startMethod(methodName);
    }
    boolean retVal = true;
    /*
     *  BLOCK for the spec'd time
     */
    try
    {
      Thread.sleep(waitTime);
    }
    catch (InterruptedException iex)
    {
      retVal = false;
    }
    if (log_ != null)
    {
      //log_.endMethod();
    }
    return retVal;
  }


  /**
   *  A method to simply sort a Hashtable holding a String key & Integer values) by its Highest To Lowest values
   * then alphabetical (low to high) for the keys.  Default is to sort Integer Highest to lowest.
   *
   * @param  hIn  the original hashtable to sort.
   * @return      the sorted      ArrayList
   */
  public static ArrayList<Set<Map.Entry<String, Integer>>> sortByValues(Hashtable<String, Integer> hIn)
  {
    final String methodName = CLASSNAME + ": sortByValues(Hashtable)";
    if (log_ != null)
    {
      //log_.startMethod(methodName);
    }
    return sortByValues(hIn, false);
  }


  /**
   *  A method to simply sort a Hashtable(holding a String key & Integer values) by its Integer values
   *  then by its String keys. The boolean ascendingOrder controls direction of sort:
   * false means descending Integer sort (High to low) then Alpahbetical -low to Highest
   * true means ascending Integer sort then Alpahbetical -Highest To Lowest.
   *
   * @param  hIn  the original hashtable to sort.
   * @ param ascendingOrder true will reverse the Order of the sorting to Integervalues low to high then String keys High to low (Reverse Alpha)
   * @return      the sorted      ArrayList
   */
  public static ArrayList<Set<Map.Entry<String, Integer>>> sortByValues(Hashtable<String, Integer> hIn, final boolean ascendingOrder)
  {
    final String methodName = CLASSNAME + ": sortByValues(Hashtable)";
    if (log_ != null)
    {
      //log_.startMethod(methodName);
    }
    boolean debugOut = false;

    Hashtable<Object, Object> retVal = null;
    //Put keys and values in to an arraylist using entryset
    ArrayList myArrayList=new ArrayList(hIn.entrySet());
    if (debugOut) System.out.println("\n\nsorting hashtable: "+hIn.toString());
    if (debugOut) System.out.println("\n\nsorting ArrayList: "+myArrayList.toString());

    //Sort the values based on values first and then keys.
    Collections.sort(myArrayList,
          new Comparator()
          {
            public int compare(Object obj1, Object obj2)
            {
              int result=0;
              Map.Entry e1 = (Map.Entry)obj1 ;
              Map.Entry e2 = (Map.Entry)obj2 ;//Sort based on values.

              Integer value1 = (Integer)e1.getValue();
              Integer value2 = (Integer)e2.getValue();
              if(value1.compareTo(value2)==0) // if the Integers are the same then sort by the String
              {
                String word1=(String)e1.getKey();
                String word2=(String)e2.getKey();
                if (ascendingOrder)
                {
                  result=word2.compareToIgnoreCase(word1);
                }
                else
                {
                  //Sort String in an alphabetical order
                  result=word1.compareToIgnoreCase(word2);
                }
              }
              else
              {
                if (ascendingOrder)
                {
                  //Sort values in a ascending order
                  result=value1.compareTo( value2 );
                }
                else
                {
                  //Sort values in a descending order
                  result=value2.compareTo( value1 );
                }
              }
              return result;
            }  // compare
          }  // MyValueComparator
      ); //Collections.sort

    if (debugOut)
    {
      //Show sorted results
      Iterator itr=myArrayList.iterator();
      String key="";
      int value=0;
      int cnt=0;
      while(itr.hasNext())
      {
        cnt++;
        Map.Entry e=(Map.Entry)itr.next();

        key = (String)e.getKey();
        value = ((Integer)e.getValue()).intValue();

        System.out.println(key+", "+value);
      }
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    return myArrayList ;
  }


  /**
   *  Encapsulates the showing of the FileChooser dialog and returns a String
   *  representing the absolute path. <P>
   *
   *  NO file filters will be used and NO directory selection is allowed.
   *
   * @param  parent     the owner of this dialog (generally just send this)
   * @param  startPath  the dir to start the file chooser dialog from
   * @return            the absolute path of the chosen file.
   */
  public static String chooseAFilename(Component parent, String startPath)
  {
    initUtil();
    final String methodName = CLASSNAME + ": chooseAFilename(String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    return chooseAFilename(parent, startPath, null, false);
  }


  /**
   *  Encapsulates the showing of the FileChooser dialog and returns a String
   *  representing the absolute path.<P>
   *
   *  This method requires all the config parms specified by the
   *  ExampleFileFilter.
   *
   * @param  parent        the owner of this dialog (generally just send this)
   * @param  startPath     the dir to start the file chooser dialog from
   * @param  filters       an array holding the Filters to use in the dialog
   * @param  filesAndDirs  specs if the user will be allowed to choose both
   *      files or dirs.
   * @return               the absolute path of the chosen file.
   */
  public static String chooseAFilename(Component parent,
      String startPath,
      ExampleFileFilter[] filters,
      boolean filesAndDirs
      )
  {
    return chooseAFilename(parent, startPath, filters,
        filesAndDirs, Util.OPEN_DIALOG);
  }


  /**
   *  Encapsulates the showing of the FileChooser dialog and returns a String
   *  representing the absolute path.<P>
   *
   *  This method requires all the config parms specified by the
   *  ExampleFileFilter.
   *
   * @param  parent        the owner of this dialog (generally just send this)
   * @param  startPath     the dir to start the file chooser dialog from
   * @param  filters       an array holding the Filters to use in the dialog
   * @param  filesAndDirs  specs if the user will be allowed to choose both
   *      files or dirs.
   * @param  openOrClose   Description of the Parameter
   * @return               the absolute path of the chosen file.
   */
  public static String chooseAFilename(Component parent,
      String startPath,
      ExampleFileFilter[] filters,
      boolean filesAndDirs,
      short openOrClose)
  {
    initUtil();
    final String methodName = CLASSNAME +
        ": chooseAFilename(String,ExampleFileFilter[],boolean)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    String retVal = "";
    JFileChooser chooser = new JFileChooser();
    if (filters != null && filters.length > 0)
    {
      for (int i = 0; i < filters.length; i++)
      {
        chooser.addChoosableFileFilter(filters[i]);
      }
      chooser.setFileFilter(filters[0]);
    }
    if (filesAndDirs)
    {
      chooser.setFileSelectionMode(JFileChooser.FILES_AND_DIRECTORIES);
    }
    if (openOrClose == SAVE_DIALOG)
    {
      if (chooser.showSaveDialog(parent) == JFileChooser.APPROVE_OPTION)
      {
        retVal = chooser.getSelectedFile().getAbsolutePath();
        System.out.println("You chose this file: " + retVal);
      }
    }
    else
    {
      if (chooser.showOpenDialog(parent) == JFileChooser.APPROVE_OPTION)
      {
        retVal = chooser.getSelectedFile().getAbsolutePath();
        System.out.println("You chose this file: " + retVal);
      }
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Converts an Absolute path to a relative path from the VM Working Dir.
   *
   * @param  absPath  is the File to use to to convert
   * @return null if can't be done, otherwise it returns the relative path.
   */
  public static String absoluteToPwdRelativePath(File absPath)
  {
    String retVal = null;
    if (absPath !=null)
      retVal = absoluteToPwdRelativePath(absPath.getAbsolutePath());

     return retVal;
  }


  /**
   *  Converts an Absolute path to a relative path from the VM Working Dir.
   *
   * @param  absPath  is the absolute path  to convert
   * @return null if can't be done, otherwise it returns the relative path.
   */
  public static String absoluteToPwdRelativePath(String absPath)
  {
    initUtil();
    final String methodName = CLASSNAME + ": getFileDir(String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    String retVal = null;

    String pwd = System.getProperty("user.dir");
    if (absPath != null && absPath.indexOf(pwd) != -1)
    {
      // Found It
      retVal = absPath.substring(pwd.length()+1);
    }

    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Removes a '/..' from the filename string and returns the corrected dir
   *  name reference. For Example :   pass it "/a/b/c/../d" it returns "/a/b/d".
   *
   * @param  path  is the absolute path  to convert
   * @return null if can't be done, otherwise it returns the corrected path.
   */
  public static String removeParentRelativeReference(String path)
  {
    initUtil();
    final String methodName = CLASSNAME + ": removeParentRelativeReference(String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    String retVal = path;
    String parentRefString = SYSTEM_FILE_SEPERATOR+"..";
    int spot = -1;
    int removeSpot = -1;

    //System.out.println("Path = "+path);
    //System.out.println("parentRef = "+parentRefString);
    if (path != null)
    {
      spot = retVal.indexOf(parentRefString);
      while (spot != -1)
      {
        // Found It
        removeSpot = retVal.substring(0,spot-1).lastIndexOf(SYSTEM_FILE_SEPERATOR);
        retVal = retVal.substring(0,removeSpot)+retVal.substring(spot+3);

        //System.out.println("spot = "+spot);
        //System.out.println("removeSpot = "+removeSpot);
        //System.out.println("retVal = "+retVal);

        spot = retVal.indexOf(parentRefString);
      }
    }

    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Creates a File representing the Dir for the specified filename string.
   *
   * @param  fileString  is the filename to get the dir for
   */
  public static File getFileDir(String fileString)
  {
    initUtil();
    final String methodName = CLASSNAME + ": getFileDir(String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    File retVal = null;
    if (fileString != null &&
        !fileString.equals(""))
    {
      int endSpot = fileString.lastIndexOf(File.separator);
      if(endSpot >=0)
      {
        retVal = new File(fileString.substring(0,endSpot));
      }
      else
      {
        retVal = new File(".");
      }
    }

    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Gets a string representing the Dir for the specified filename string.
   *
   * @param  fileString  is the filename to get the dir for
   */
  public static String getFileDirStr(String fileString)
  {
    initUtil();
    final String methodName = CLASSNAME + ": getFileDirStr(String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    String retVal = null;
    if (fileString != null &&
        !fileString.equals(""))
    {
      int endSpot = fileString.lastIndexOf(File.separator);
      if(endSpot >=0)
      {
        retVal = fileString.substring(0,endSpot);
      }
      else
      {
        retVal = ".";
      }
    }

    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Creates a URL for the specified filename string.
   *
   * @param  fileString  is the filename to turn into a file://URL
   * @return             the converted file://URL
   */
  public static URL getFileBaseURL(String fileString)
  {
    initUtil();
    final String methodName = CLASSNAME + ": getFileBaseURL(String)";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    /*
     *  because this is an application the codebase does not work
     */
    /*
     *  we have to create the codeBase URL from the userDir
     */
    URL convertedURL = null;
    int i = 0;
    String tempPath = null;
    try
    {
      // 1st see if the string is already a URL
      convertedURL = new URL(fileString);
    }
    catch (MalformedURLException ex)
    {
      try
      {
        try
        {
          /*
           *  1st test if this is a DOS/OS/2 style path with a drive letter
           */
          if (fileString.charAt(1) == ':')
          {
            tempPath = fileString.substring(0, 1);
            tempPath += ":";
            /*
             *  Replace the file separators with the forward slash
             */
            for (i = 2; i <= fileString.length() - 1; i++)
            {
              if (fileString.charAt(i) != SYSTEM_FILE_SEPERATOR.charAt(0))
              {
                tempPath += fileString.substring(i, i + 1);
              }
              else
              {
                tempPath += "/";
              }
            }
            //System.out.print("Appears to be a DOS or OS/2 filesystem - ");
            convertedURL = new URL("FILE:////" +encodeToURL( tempPath));
            //System.out.println(""+ convertedURL);
          }
          else
          {
            /*
             *  2nd test if this is a UN*x style path without a drive letter
             */
            if (fileString.charAt(0) == '/')
            {
              //System.out.println("Appears to be a Unix filesystem");
              //convertedURL = new URL("file://" + fileString);
              convertedURL = new URL("file","", encodeToURL(fileString));
            }
            else
            {
              //System.out.println("Appears to be a relative filesystem");
              convertedURL = new URL("file://./");
              convertedURL = new URL("file","", encodeToURL(fileString));
            }
          }
          //  System.out.println("APP convertedURL=" + convertedURL.toString());
        }
        catch (java.net.MalformedURLException t)
        {
          System.out.println("caught java.net.MalformedURLException: " + t +
              "Cannot retrieve User Directory");
          t.printStackTrace();
        }
      }
      catch (StringIndexOutOfBoundsException t)
      {
        System.out.println("caught StringIndexOutOfBoundsException: " + t +
            "Cannot retrieve User Directory");
        t.printStackTrace();
      }
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    return convertedURL;
  }


  /**
   *  Creates a URL[] for the given Strings.
   *
   * @param  fileStrings  Description of Parameter
   * @return              The FileBaseURLs value
   */
  public static URL[] getFileBaseURLs(String[] fileStrings)
  {
    final String methodName = CLASSNAME + ": getFileBaseURLs(String[])";
    initUtil();
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    URL[] retVal = null;
    if (fileStrings != null)
    {
      int size = fileStrings.length;
      //      System.out.println("Into getFileBaseURLs " + size);
      retVal = new URL[size];
      for (int i = 0; i < size; i++)
      {
        retVal[i] = getFileBaseURL(fileStrings[i]);
      }
    }
    if (log_ != null)
    {
      log_.endMethod();
    }

    return retVal;
  }



  /**
   * Encode a string to the "x-www-form-urlencoded" form, enhanced
   * with the UTF-8-in-URL proposal. This is what happens:
   *
   * <ul>
   * <li><p>The ASCII characters 'a' through 'z', 'A' through 'Z',
   *        and '0' through '9' remain the same.
   *
   * <li><p>The unreserved characters - _ . ! ~ * ' ( ) remain the same.
   *
   * <li><p>The space character ' ' is converted into a plus sign '+'.
   *
   * <li><p>All other ASCII characters are converted into the
   *        3-character string "%xy", where xy is
   *        the two-digit hexadecimal representation of the character
   *        code
   *
   * <li><p>All non-ASCII characters are encoded in two steps: first
   *        to a sequence of 2 or 3 bytes, using the UTF-8 algorithm;
   *        secondly each of these bytes is encoded as "%xx".
   * </ul>
   *
   * @param s The string to be encoded
   * @return The encoded string
   */
  public static String encodeToURL(String s)
  {
    StringBuffer sbuf = new StringBuffer();
    int len = s.length();
    for (int i = 0; i < len; i++) {
      int ch = s.charAt(i);
      if ('A' <= ch && ch <= 'Z') {             // 'A'..'Z'
        sbuf.append((char)ch);
      } else if ('a' <= ch && ch <= 'z') {      // 'a'..'z'
         sbuf.append((char)ch);
      } else if ('0' <= ch && ch <= '9') {      // '0'..'9'
         sbuf.append((char)ch);
      } else if (ch == ' ') {                   // space
         sbuf.append('+');
      } else if (ch == '-' || ch == '_'         // unreserved
          || ch == '.' || ch == '!'
          || ch == '~' || ch == '*'
          || ch == '\'' || ch == '('
          || ch == ')') {
        sbuf.append((char)ch);
      } else if (ch <= 0x007f) {                // other ASCII
         sbuf.append(hex[ch]);
      } else if (ch <= 0x07FF) {                // non-ASCII <= 0x7FF
         sbuf.append(hex[0xc0 | (ch >> 6)]);
         sbuf.append(hex[0x80 | (ch & 0x3F)]);
      } else {                                  // 0x7FF < ch <= 0xFFFF
         sbuf.append(hex[0xe0 | (ch >> 12)]);
         sbuf.append(hex[0x80 | ((ch >> 6) & 0x3F)]);
         sbuf.append(hex[0x80 | (ch & 0x3F)]);
      }
    }
    return sbuf.toString();
  }


  /*
   * Created: 17 April 1997
   * Author: Bert Bos <bert@w3.org>
   *
   * unescape: http://www.w3.org/International/unescape.java
   *
   * Copyright © 1997 World Wide Web Consortium, (Massachusetts
   * Institute of Technology, European Research Consortium for
   * Informatics and Mathematics, Keio University). All Rights Reserved.
   * This work is distributed under the W3C® Software License [1] in the
   * hope that it will be useful, but WITHOUT ANY WARRANTY; without even
   * the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR
   * PURPOSE.
   *
   * [1] http://www.w3.org/Consortium/Legal/2002/copyright-software-20021231
   */
  public static String decodeURL(String s)
  {
    StringBuffer sbuf = new StringBuffer () ;
    int l  = s.length() ;
    int ch = -1 ;
    int b, sumb = 0;
    for (int i = 0, more = -1 ; i < l ; i++)
    {
      /* Get next byte b from URL segment s */
      switch (ch = s.charAt(i))
      {
        case '%':
          ch = s.charAt (++i) ;
          int hb = (Character.isDigit ((char) ch)
              ? ch - '0'
              : 10+Character.toLowerCase((char) ch) - 'a') & 0xF ;
          ch = s.charAt (++i) ;
          int lb = (Character.isDigit ((char) ch)
              ? ch - '0'
              : 10+Character.toLowerCase ((char) ch)-'a') & 0xF ;
          b = (hb << 4) | lb ;
          break ;

        case '+':
          b = ' ' ;
          break ;

        default:
          b = ch ;
      }
      /* Decode byte b as UTF-8, sumb collects incomplete chars */
      if ((b & 0xc0) == 0x80)
      {                 // 10xxxxxx (continuation byte)
        sumb = (sumb << 6) | (b & 0x3f) ;       // Add 6 bits to sumb
        if (--more == 0) sbuf.append((char) sumb) ; // Add char to sbuf
      }
      else if ((b & 0x80) == 0x00)
      {         // 0xxxxxxx (yields 7 bits)
        sbuf.append((char) b) ;                 // Store in sbuf
      }
      else if ((b & 0xe0) == 0xc0)
      {         // 110xxxxx (yields 5 bits)
        sumb = b & 0x1f;
        more = 1;                               // Expect 1 more byte
      }
      else if ((b & 0xf0) == 0xe0)
      {         // 1110xxxx (yields 4 bits)
        sumb = b & 0x0f;
        more = 2;                               // Expect 2 more bytes
      }
      else if ((b & 0xf8) == 0xf0)
      {         // 11110xxx (yields 3 bits)
        sumb = b & 0x07;
        more = 3;                               // Expect 3 more bytes
      }
      else if ((b & 0xfc) == 0xf8)
      {         // 111110xx (yields 2 bits)
        sumb = b & 0x03;
        more = 4;                               // Expect 4 more bytes
      }
      else /*if ((b & 0xfe) == 0xfc)*/
      { // 1111110x (yields 1 bit)
        sumb = b & 0x01;
        more = 5;                               // Expect 5 more bytes
      }
      /* We don't test if the UTF-8 encoding is well-formed */
    }
    return sbuf.toString() ;
  }


  /**
   *  gets the current VMs localhost address.
   *
   * @return    the current VMs localhost address, Null if it can't be gotten.
   */
  public static InetAddress getLocalhostName()
  {
    initUtil();
    final String methodName = CLASSNAME + ": getLocalhostrName()";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    InetAddress retVal = null;
    try
    {
      retVal = InetAddress.getLocalHost();
    }
    catch (UnknownHostException unknownEx)
    {
      log_.minor("Cant't get the hostname address.", unknownEx);
    }
    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /** Calculated the BCH GIS location in Lat/Long of a  BCH GIS x,y asset position.
   *  BCH GIS is a Lambert Conformal Projection for BC Hydro.
   <pre>
    proj -I +proj=lcc +lat_1=50 +lat_2=56 +lat_0=53.0 +lon_0=-123.0 +x_0=0 +y_0=0 +ellps=GRS80 +datum=NAD83 +units=cm

    The Well Know Text (WKT) is:
    PROJCS["BC Hydro Lambert Conformal Conic",
          GEOGCS["North American Datum_1983",
          DATUM["North American Datum 1983",
          SPHEROID["Geodetic Reference System of 1980",6378137,298.2572221009113]],
          PRIMEM["Greenwich",0],
          UNIT["Decimal Degree",0.0174532925199433]],
    PROJECTION["Lambert Conformal Conic 2SP"],
    PARAMETER["standard_parallel_1",50],
    PARAMETER["standard_parallel_2",56],
    PARAMETER["latitude_of_origin",53],
    PARAMETER["central_meridian",-123],
    PARAMETER["false_easting",0],
    PARAMETER["false_northing",0],
    UNIT["METER",1]]
   </pre>

   see http://www.geoapi.org/2.0/javadoc/org/opengis/referencing/doc-files/WKT.html
   **/
   /*
  public static LatLong getBCHAssetLatLong(double x, double y) throws IllegalArgumentException
  {
    LatLong retVal = new LatLong();
    String bchWKT = "PROJCS[\"BC Hydro Lambert Conformal Conic\",\n"+
                    "       GEOGCS[\"North American Datum 1983\",\n"+
                    "              DATUM[\"North American Datum 1983\",\n"+
                    "                    SPHEROID[\"Geodetic Reference System of 1980\",6378137,298.2572221009113]],\n"+
                    "              PRIMEM[\"Greenwich\",0],\n"+
                    "              UNIT[\"Decimal Degree\",0.0174532925199433]],\n"+
                    "       PROJECTION[\"Lambert_Conformal_Conic_2SP\"],\n"+
                    "       PARAMETER[\"standard_parallel_1\",50],\n"+
                    "       PARAMETER[\"standard_parallel_2\",56],\n"+
                    "       PARAMETER[\"latitude_of_origin\",52.991936976411],\n"+ // 52.991936976411
                    "       PARAMETER[\"central_meridian\",-123.0161404723602],\n"+ // -123.0161404723602
                    "       PARAMETER[\"false_easting\",0],\n"+
                    "       PARAMETER[\"false_northing\",0],\n"+
                    "       UNIT[\"METER\",1]]";

    Parser parser = new Parser();

    try
    {
      CoordinateReferenceSystem crs = parser.parseCoordinateReferenceSystem(bchWKT) ;
      // org.geotools.referencing.crs.DefaultProjectedCRS
      //System.out.println("The CRS is of type: "+crs.getClass().getName());

      DefaultProjectedCRS bchCrs = (DefaultProjectedCRS) crs;

      GeodeticCalculator gc = new GeodeticCalculator(bchCrs) ;

      if (false) // debug statements
      {
        System.out.println("  Initial Starting Position (meters)="+  gc.getStartingPosition());
        //System.out.println("  datum="+  bchCrs.getDatum());
        System.out.println("\n  WKT="+  bchCrs.toWKT());

      }

      // set the start measure position to the BCH Origin
      gc.setStartingGeographicPoint(LatLong.BCH_LONG_ORIGIN, LatLong.BCH_LAT_ORIGIN); //this is now built into the Parsed CRS
      //java.awt.geom.Point2D bchOriginLatLong = new java.awt.geom.Point2D.Double(LatLong.BCH_LONG_ORIGIN, LatLong.BCH_LAT_ORIGIN);

      //gc.setDestinationGeographicPoint(x,y); //new java.awt.geom.Point2D.Float(x,y));
      gc.setDestinationPosition(new GeneralDirectPosition(x,y) ); //new java.awt.geom.Point2D.Float(x,y));

      // TEST
      //gc.setDestinationGeographicPoint(bchOriginLatLong);

      GeneralDirectPosition startPosition =  (GeneralDirectPosition)gc.getStartingPosition();
      GeneralDirectPosition destPosition =  (GeneralDirectPosition)gc.getDestinationPosition();  // returns the CRS unit (meters)
      java.awt.geom.Point2D startLatLong = gc.getStartingGeographicPoint() ;  //The x and y coordinates are the longitude and latitude in decimal degrees, respectively.
      java.awt.geom.Point2D destLatLong = gc.getDestinationGeographicPoint();  //The x and y coordinates are the longitude and latitude in decimal degrees, respectively.
      retVal = new LatLong(destLatLong.getY(), destLatLong.getX());

      if (false) // debug statements
      {
        System.out.println("\n------------------------------\n  Starting Position (meters)="+ startPosition);
        System.out.println("Detination Position (meters)="+ destPosition);
        System.out.println("\n  Starting Position (LatLong) Lat="+ startLatLong.getY()+ "   Long="+ startLatLong.getX());
        System.out.println("Detination Position (LatLong) Lat="+ destLatLong.getY()+ "   Long="+ destLatLong.getX());
        System.out.println("Distance="+         gc.getOrthodromicDistance() );
      }

    }
    catch (TransformException tEx)
    {
      tEx.printStackTrace();
    }
    catch(java.text.ParseException pEx)
    {
      pEx.printStackTrace();
    }
    catch(Exception ex)
    {
      ex.printStackTrace();
    }
    return retVal;
  }
  */

  /** Calculates the Distance in meters between two LatLong points on the earth assuming it is a perfect sphere. **/
  public static double sphereDistanceBetween(double lat1, double lng1, double lat2, double lng2)
  {
    double earthRadius = 3958.75; // this is in miles
    double dLat = Math.toRadians(lat2-lat1);
    double dLng = Math.toRadians(lng2-lng1);
    double a = Math.sin(dLat/2) * Math.sin(dLat/2) +
               Math.cos(Math.toRadians(lat1)) * Math.cos(Math.toRadians(lat2)) *
               Math.sin(dLng/2) * Math.sin(dLng/2);
    double c = 2 * Math.atan2(Math.sqrt(a), Math.sqrt(1-a));
    double dist = earthRadius * c;

    double meterConversion = 1609.344;

    return (dist * meterConversion);
    }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.  This method inherits the current workingDir.
   *
   * @param executableLocation is the path to the executable to run
   * @param cmds and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param verboseOutput flag for optionaly printing extra application state output.
   *
   * @return returns the captured output from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static String executeNativeApp(String executableLocation,
                                          String[] cmds,
                                          boolean verboseOutput)
  { return executeNativeApp(executableLocation, cmds, verboseOutput, null); }

  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters and Working Directory. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param cmds and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param verboseOutput flag for optionaly printing extra application state output.
   * @param workingDir the working dir to exec from - To inherit current, pass a null.
   *
   * @return returns the captured output from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static String executeNativeApp(String executableLocation,
                                          String[] cmds,
                                          boolean verboseOutput,
                                          String workingDir)
  {
    final String methodName = CLASSNAME + ": executeNativeApp(String,String[],boolean)";
    initUtil();
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    String retVal = "";

    StreamGobbler inputGobbler = new StreamGobbler();
    inputGobbler.setCapture(true);
    executeNativeApp(executableLocation,cmds,null,inputGobbler,verboseOutput, workingDir);
    log_.debug("App Execution Complete");
    retVal = inputGobbler.getCapturedOutput();

    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param cmds and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param outFilename an outputFile to dump the exe output (If this is null
   *                    it sends the output to System.out).
   * @param verboseOutput flag for optionaly printing extra applicvation state output.
   *
   * @return returns the return code from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static int executeNativeApp(String executableLocation,
                      String[] cmds,
                      String outFilename,
                      boolean verboseOutput)
  {
    return executeNativeApp(executableLocation,
                             cmds,
                             outFilename,
                             null,
                             verboseOutput,
                             null);
  }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param appParms and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param outFilename an outputFile to dump the exe output (If this is null
   *                    it sends the output to System.out).
   * @param inputGobbler is the StreamGobbler object to use in gobbling the Commands InputStream.
   * @param verboseOutput flag for optionaly printing extra applicvation state output.
   *
   * @return returns the return code from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static int executeNativeApp(String executableLocation,
                      Vector appParms,
                      String outFilename,
                      StreamGobbler inputGobbler,
                      boolean verboseOutput)
  { return executeNativeApp(executableLocation, appParms, outFilename, inputGobbler, verboseOutput, null); }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param appParms and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param outFilename an outputFile to dump the exe output (If this is null
   *                    it sends the output to System.out).
   * @param inputGobbler is the StreamGobbler object to use in gobbling the Commands InputStream.
   * @param verboseOutput flag for optionaly printing extra applicvation state output.
   * @param workingDir the working dir to exec from - To inherit current, pass a null.
   *
   * @return returns the return code from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static int executeNativeApp(String executableLocation,
                      Vector appParms,
                      String outFilename,
                      StreamGobbler inputGobbler,
                      boolean verboseOutput,
                      String workingDir)
  {
    int retVal = -1;
    int cmdParms = 0;
    if (appParms != null)
      cmdParms = appParms.size();
    String [] cmds = new String [cmdParms];
    //cmds[0] = executableLocation;

    if (verboseOutput) System.out.print("Executing: "+ executableLocation);
    for (int i=0; i < cmdParms; i++)
    {
      if (verboseOutput) System.out.print(" " + i + ")");
      if (verboseOutput) System.out.print(" " + (String)appParms.elementAt(i));
      cmds[i] = (String) appParms.elementAt(i);
      if (verboseOutput) System.out.print(" " + cmds[i]);
    }
    if (verboseOutput) System.out.println("");

    return executeNativeApp(executableLocation,
                            cmds,
                            outFilename,
                            inputGobbler,
                            verboseOutput,
                            workingDir);
  }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param cmds and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param outFilename an outputFile to dump the exe output (If this is null
   *                    it sends the output to System.out).
   * @param inputGobbler is the StreamGobbler object to use in gobbling the Commands InputStream.
   * @param verboseOutput flag for optionaly printing extra applicvation state output.
   * @param workingDir the working dir to exec from - To inherit current, pass a null.
   *
   * @return returns the return code from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static int executeNativeApp(String executableLocation,
                      String[] cmds,
                      String outFilename,
                      StreamGobbler inputGobbler,
                      boolean verboseOutput,
                      String workingDir)
  {
    int retVal = -1;

    if (workingDir==null) workingDir = USERDIR;

    // Start the app... This starts a new process
    try
    {
      // set up the arrays to send to exec.
      //String[] prefix = new String[]{};
      String[] prefix = new String[]{executableLocation};
      //String[] prefix = new String[]{"cmd.exe", "/U", "/E:OFF", "/C"};
      //String[] prefix = new String[]{"start", "/I", "/B"};
      String[] actualArgs = new String[prefix.length + cmds.length];
      System.arraycopy(prefix, 0, actualArgs, 0, prefix.length);
      System.arraycopy(cmds, 0, actualArgs, prefix.length, cmds.length);

      // collect and init the environment
      ProcessRunner osSupport = ProcessRunner.getProcessRunner();
      Hashtable variables = osSupport.getEnvironmentVariables();
      String [] env = new String[variables.size()];
      if(osSupport.supportsEnvironmentVariables())
      {
        int counter = 0;
        Enumeration keys = variables.keys();
        while(keys.hasMoreElements())
        {
          Object key = keys.nextElement();
          env[counter++]= (key + "=" + variables.get(key));
        }
      }

      //for (int i=0; i < env.length; i++)
      //  System.out.println(env[i]);
      //System.out.println("");
      if (verboseOutput)
      {
        for (int i=0; i < actualArgs.length; i++)
          System.out.print(actualArgs[i] + " ");
        System.out.println("");
      }

      // get set up to get any output?
      FileOutputStream pumpedOutputFile = null;
      PrintStream pumpedPrintStream = System.out;
      if (outFilename != null && !outFilename.equals(""))
      {
        pumpedOutputFile = new FileOutputStream(outFilename);
        pumpedPrintStream = new PrintStream(pumpedOutputFile);
      }
      //set up the Gobbler
      if (inputGobbler == null) inputGobbler = new StreamGobbler();
      inputGobbler.setPrependString("");
      inputGobbler.setOs_(pumpedPrintStream);
      StreamGobbler errorGobbler = new StreamGobbler();
      errorGobbler.setPrependString("Error> ");

      // get the system call process set up and running
      Runtime runtime = Runtime.getRuntime();
      //Process p = runtime.exec(actualArgs, env, new File(".\\."));
      /*System.out.println("***Calling runtimeexec "+actualArgs[0]+","+
                          (actualArgs.length>1?actualArgs[1]+",":"")+
                          (actualArgs.length>2?actualArgs[2]+",":"")+
                          (actualArgs.length>3?actualArgs[3]+",":"")+
                          (actualArgs.length>4?actualArgs[4]+",":""));
      System.out.println("From Dir:"+workingDir);
      */
      Process p = runtime.exec(actualArgs, null, new File(workingDir));

      // capture any input we get
      // any error message?
      //StreamGobbler outputGobbler = new StreamGobbler(p.getOutputStream(), "Out> ");

      // capture any output we get
      // any error message?
      inputGobbler.setInputStream(p.getInputStream());
      errorGobbler.setInputStream(p.getErrorStream());

      // kick them off
      inputGobbler.start();
      errorGobbler.start();
      //outputGobbler.start();

      // now wait for the process to end
      try
      {
        sleep(3000);
        p.waitFor();
        if (verboseOutput) System.out.println("Process Done Executing.");
        //if (verboseOutput) System.out.println(outputGobbler.getCapturedOutput());
      }
      catch (Exception intEx)
      {
        if (verboseOutput) System.out.print("APP Interupted?");
      }
      retVal = p.exitValue();
      if (verboseOutput) System.out.println("APP return value:"+retVal);
      errorGobbler.finishedGobbling_ = true;
      //outputGobbler.finishedGobbling_ = true;
      inputGobbler.finishedGobbling_ = true;
      if (pumpedOutputFile != null)
      {
        pumpedOutputFile.flush();
        pumpedOutputFile.close();
      }
      p.destroy();
      p = null;
      runtime.gc();
    }
    catch (IOException ioEx)
    {
      System.out.println("ERROR: An IO exception occured while attempting " +
        "execution of the " + executableLocation + " application.");
        ioEx.printStackTrace();
    }
    catch (SecurityException securityEx)
    {
      System.out.println("ERROR: A Java Security Manager is in use and is " +
        "restricting execution of the " + executableLocation + " application.");
    }
    catch (Exception ex)
    {
      System.out.println("ERROR: A Java Exception Occured " +
        "restricting execution of the " + executableLocation + " application.");
      ex.printStackTrace();
    }

    return retVal;
  }


  /**
   * A Thread Watchdog that watches the passed in thread and Interupts it if it
   * has not finished by the requested time.
   *
   * @param watchThread is the thread to watch
   * @param timeToTerminate is the time to wait befor Interupting
   * @exception SecurityException If the interrupt is not allowed on the thread
   *
   * @return true or false to specify if this watchdog had to interupt.
   **/
  public static boolean threadWatchdog(final Thread watchThread,
                                          final long timeToTerminate)
                                          throws SecurityException
  {
    boolean retVal = false;

    // inline Thread to do the watching
    Thread watchdogThread = new Thread (){
      Thread threadToWatch = null;
      long timeWatched = 0;
      int sleepTime = 500;

      public void run()
      {
        watchdogReset = false;
        while (timeWatched < timeToTerminate &&
                watchThread.isAlive() &&
                !watchThread.isInterrupted() &&
                !watchdogReset)
        {
          timeWatched += sleepTime;
          try
          {
            sleep(sleepTime);
          }
          catch (InterruptedException iex)
          {
          }
        }

        if (timeWatched >= timeToTerminate)
        {
          // this throws a security exception If the interrupt is not allowed
          watchThread.interrupt();
        }
      }
    };

    watchdogThread.start();

   return retVal;
  }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects. This method defaults to
   * print System.out statements to describe the state of execution.  If you
   * don't want anything but the executed application output call the
   * overridden method with the verbose flag.
   *
   * @param executableLocation is the path to the executable to run
   *
   * @param appParms and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   *
   * @param outFilename an outputFile to dump the exe output.
   *
   * @return returns the return code from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static int executeNativeApp(String executableLocation,
                      Vector appParms,
                      String outFilename)
  {
    return executeNativeApp(executableLocation, appParms, outFilename, true);
  }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param appParms and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param outFilename an outputFile to dump the exe output (This can be null)
   * @param verboseOutput flag for optionaly printing extra applicvation state output.
   *
   * @return returns the return code from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static int executeNativeApp(String executableLocation,
                      Vector appParms,
                      String outFilename,
                      boolean verboseOutput)
  {
    int retVal = -1;
    int cmdParms = 0;
    if (appParms != null)
      cmdParms = appParms.size();
    String [] cmds = new String [cmdParms];
    //cmds[0] = executableLocation;

    if (verboseOutput) System.out.print("Executing: "+ executableLocation);
    for (int i=0; i < cmdParms; i++)
    {
      if (verboseOutput) System.out.print(" " + i + ")");
      if (verboseOutput) System.out.print(" " + (String)appParms.elementAt(i));
      cmds[i] = (String) appParms.elementAt(i);
      if (verboseOutput) System.out.print(" " + cmds[i]);
    }
    if (verboseOutput) System.out.println("");

    return executeNativeApp(executableLocation,
                            cmds,
                            outFilename,
                            verboseOutput);
  }


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param appParms and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param verboseOutput flag for optionaly printing extra applicvation state output.
   *
   * @return returns the captured results stream from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static String executeNativeApp(String executableLocation,
                      Vector appParms,
                      boolean verboseOutput)
  {return  executeNativeApp(executableLocation,appParms, verboseOutput, null);}


  /**
   * Executes the Specified Native OS application with the provided commandline
   * parameters. This method blocks until the Executed app is complete. It also
   * cleans up its sub-process and garbage collects.
   *
   * @param executableLocation is the path to the executable to run
   * @param appParms and extra commandline parameters to tag onto the
   *               end of the commandline that gets executed.
   * @param verboseOutput flag for optionaly printing extra applicvation state output.
   *
   * @return returns the captured results stream from the executed app/process
   *
   * @see StreamGobbler
   * @see java.lang.Runtime#getRuntime
   **/
  public static String executeNativeApp(String executableLocation,
                      Vector appParms,
                      boolean verboseOutput,
                      String workingDir)
  {
    int cmdParms = 0;
    if (appParms != null)
      cmdParms = appParms.size();
    String [] cmds = new String [cmdParms];
    //cmds[0] = executableLocation;

    if (verboseOutput) System.out.print("Executing: "+ executableLocation);
    for (int i=0; i < cmdParms; i++)
    {
      if (verboseOutput) System.out.print(" " + i + ")");
      if (verboseOutput) System.out.print(" " + (String)appParms.elementAt(i));
      cmds[i] = (String) appParms.elementAt(i);
      if (verboseOutput) System.out.print(" " + cmds[i]);
    }
    if (verboseOutput) System.out.println("");

    return executeNativeApp(executableLocation,
                            cmds,
                            verboseOutput,
                            workingDir);
  }


    /**
   *  gets the current date and time.
   *
   * @return    the current Date.
   */
  public static Date getCurrentDate()
  {
    initUtil();
    final String methodName = CLASSNAME + ": getCurrentDate()";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    Date retVal = new Date();
    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }


  /**
   *  Counts the files in a dir (optionally recurses sub dirs)
   *
   * @param  dirName
   * @param  recurse
   * @return          the number of files (not counting the directories)
   */
  public static long countFilesInDir(String dirName,
      boolean recurse)
  {
    initUtil();
    final String methodName = CLASSNAME + ": countFilesInDir()";
    if (log_ != null)
    {
      log_.startMethod(methodName);
    }
    long retVal = 0L;
    File dirFile = new File(dirName);

    if (dirFile.isDirectory() && dirFile.canRead())
    {
      String[] waste = dirFile.list();
      File tempFile = null;
      for (int i = 0; i < waste.length; i++)
      {
        tempFile = new File(dirName + File.separator + waste[i]);
        if (tempFile != null && !tempFile.isDirectory())
        {
          retVal++;
        }
        else if (tempFile != null && recurse)
        {
          retVal +=
              countFilesInDir(dirName + File.separator + waste[i], true);
        }
      }
    }

    if (log_ != null)
    {
      log_.endMethod();
    }
    return retVal;
  }

  public static void main(String [] args)
  {
    final String methodName = CLASSNAME + ": main()";
    initUtil();
    /*if (log_ != null)
    {
      //log_.setLogFile(Log.CONSOLE);
      log_.setLogLevel(Log.FULL);
      log_.startMethod(methodName);
    } */
    log_.debug("args: ");
    for (int i=1; i < args.length; i++) log_.debug(""+i+" "+args[i]);

    StringBuffer helpMsg = new StringBuffer(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("---  WebARTS Util Class  --------------------------------");
    helpMsg.append("----------------------");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("WebARTS Util Class");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("SYNTAX:");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("   java ca.bc.webarts.widgets.Util methodName methodArgs");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("Available Methods:");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   ensureFolderExists fullDirectoryName||fullFilename");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   removeDir fullDirectoryName fullDirectoryName2 ...");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   createCurrentTimeStamp");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   createCurrentDateTimeStamp");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   capsToSpacesInString StringToConvert");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   spacesToCapsInString  StringToConvert");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   spacesToCapsInDir  directoryName");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   removeParentRelativeReference  pathName");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   countFilesInDir  fullDirectoryName");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   dirSize  fullDirectoryName");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   removeOldFiles fullDirectoryName daysOld");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   testHexConverters decimalNumber [decimalNumber2] [decimalNumber3] [...]");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   sleep ms");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   executeNativeApp executableLocation [parms] ");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   findFile fileToFind [dirToStart] [recurseSubDirs] [regExp] ");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("       - if using a regExp, the fileToFind param is a quoted Java regExp such as \"[*.png]\" or \"[a-zA-Z*.zip]\"");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   searchInFile file/dirToSearch searchStr");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   tokenReplaceInFile file/dirToSearch tokenStr replaceStr ");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   tokenReplaceInRecursedFile file/dirToSearch tokenStr replaceStr ");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   zipUpFile filename ");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("-->   renameFile fromFilename toFilename");
    helpMsg.append("       - Renames the specified fromFile to the toFilename in the same directory.");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append(SYSTEM_LINE_SEPERATOR);
    helpMsg.append("---------------------------------------------------------");
    helpMsg.append("----------------------");
    helpMsg.append(SYSTEM_LINE_SEPERATOR);

    if (args ==null || args.length<1)
      System.out.println(helpMsg.toString());
    else
    {
      // *****************************************************
      if (args[0].equals("removeDir"))
      {
        if (args.length >1)
        {
          File tmpDirFile = null;
          for (int i=1; i < args.length; i++)
          {
            if ((tmpDirFile = initDirFile(args[i])) != null)
            {
              if (removeDir(args[i]))
                System.out.println("Directory Removed: "+args[i]);
              else
                System.out.println("Directory NOT Removed successfully: "+args[i]);
            }
            else
            {
              helpMsg.append("ERROR: Cannot find the Directory named:");
              helpMsg.append(SYSTEM_LINE_SEPERATOR);
              helpMsg.append(args[i]);
              System.out.println(helpMsg.toString());
            }
          }
        }
        else
        {
          helpMsg.append("ERROR: The removeDir method requires at least 1");
          helpMsg.append(" directory name to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      if (args[0].equals("ensureFolderExists"))
      {
        if (args.length >1)
        {
          File tmpDirFile = null;
          for (int i=1; i < args.length; i++)
          {
            ensureParentFolderExists(args[i]);
          }
        }
        else
        {
          helpMsg.append("ERROR: The ensureFolderExists method requires at least 1");
          helpMsg.append(" directory name to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("countFilesInDir"))
      {
        if (args.length >1)
        {
          File tmpDirFile = null;
          for (int i=1; i < args.length; i++)
          {
            if ((tmpDirFile = initDirFile(args[i])) != null)
            {
              long retVal = countFilesInDir(args[i], true);
              System.out.println("Number Of Files = " + retVal);
            }
            else
            {
              helpMsg.append("ERROR: Cannot find the Directory named:");
              helpMsg.append(SYSTEM_LINE_SEPERATOR);
              helpMsg.append(args[i]);
              System.out.println(helpMsg.toString());
            }
          }
        }
        else
        {
          helpMsg.append("ERROR: The countFilesInDir method requires 1");
          helpMsg.append(" directory name to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("countFilesInDir"))
      {
        if (args.length >1)
        {
          File tmpDirFile = null;
          for (int i=1; i < args.length; i++)
          {
            if ((tmpDirFile = initDirFile(args[i])) != null)
            {
              long retVal = countFilesInDir(args[i], true);
              System.out.println("Number Of Files = " + retVal);
            }
            else
            {
              helpMsg.append("ERROR: Cannot find the Directory named:");
              helpMsg.append(SYSTEM_LINE_SEPERATOR);
              helpMsg.append(args[i]);
              System.out.println(helpMsg.toString());
            }
          }
        }
        else
        {
          helpMsg.append("ERROR: The countFilesInDir method requires 1");
          helpMsg.append(" directory name to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("tokenReplaceInFile"))
      {
        if (args.length == 4)
        {
          File rootFile = new File(args[1]);
          if (rootFile != null && !rootFile.isDirectory() && rootFile.canRead())
          {
            tokenReplaceInFile(args[1], args[2], args[3]);
          }
          else
          {
            helpMsg.append("ERROR: Cannot find the file named:");
            helpMsg.append(SYSTEM_LINE_SEPERATOR);
            helpMsg.append(args[1]);
            System.out.println(helpMsg.toString());
          }
        }
        else
        {
          helpMsg.append("ERROR: The tokenReplaceInFile method requires");
          helpMsg.append(" 3 parameters:\n a file name to operate on,\n");
          helpMsg.append("the the token string to search for in the file, and \n");
          helpMsg.append("the replacement string");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("tokenReplaceInRecursedFile"))
      {
        boolean recurseSubdirs = true;
        if (args.length == 4)
        {
          File rootFile = new File(args[1]);
          if (rootFile != null && rootFile.canRead())
          {
            tokenReplaceInFile(args[1], args[2], args[3], true);
          }
          else
          {

            helpMsg.append("ERROR: Cannot find the file named:");
            helpMsg.append(SYSTEM_LINE_SEPERATOR);
            helpMsg.append(args[1]);
            System.out.println(helpMsg.toString());
          }
        }
        else
        {
          helpMsg.append("ERROR: The tokenReplaceInRecursedFile method requires");
          helpMsg.append(" 3 parameters:\n a file name to operate on,\n");
          helpMsg.append("the the token string to search for in the file, and \n");
          helpMsg.append("the replacement string");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("dirSize"))
      {
        if (args.length >1)
        {
          File tmpDirFile = null;
          for (int i=1; i < args.length; i++)
          {
            if ((tmpDirFile = initDirFile(args[i])) != null)
            {
              long retVal = dirSize(args[i], true);
              DecimalFormat decForm = new DecimalFormat("##0.000E0");
              String formattedRetVal = decForm.format(retVal);
              if ((formattedRetVal.substring(formattedRetVal.length()-1)).
                  equals("9"))
                formattedRetVal =
                  formattedRetVal.substring(0,formattedRetVal.length()-2)+" Gb";
              else if ((formattedRetVal.substring(formattedRetVal.length()-1)).
                  equals("6"))
                formattedRetVal =
                  formattedRetVal.substring(0,formattedRetVal.length()-2)+" Mb";
              else if ((formattedRetVal.substring(formattedRetVal.length()-1)).
                  equals("3"))
                formattedRetVal =
                  formattedRetVal.substring(0,formattedRetVal.length()-2)+" kb";

              //formattedRetVal = decForm.format(retVal);
              System.out.println("Directory size = " + formattedRetVal);

            }
            else
            {
              helpMsg.append("ERROR: Cannot find the Directory named:");
              helpMsg.append(SYSTEM_LINE_SEPERATOR);
              helpMsg.append(args[i]);
              System.out.println(helpMsg.toString());
            }
          }
        }
        else
        {
          helpMsg.append("ERROR: The dirSize method requires 1");
          helpMsg.append(" directory name to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("dirSize2"))
      {
        if (args.length >1)
        {
          File tmpDirFile = null;
          for (int i=1; i < args.length; i++)
          {
            if ((tmpDirFile = initDirFile(args[i])) != null)
            {
              long retVal = dirSize2(args[i], true);
              DecimalFormat decForm = new DecimalFormat("##0.000E0");
              String formattedRetVal = decForm.format(retVal);
              if ((formattedRetVal.substring(formattedRetVal.length()-1)).
                  equals("9"))
                formattedRetVal =
                  formattedRetVal.substring(0,formattedRetVal.length()-2)+" Gb";
              else if ((formattedRetVal.substring(formattedRetVal.length()-1)).
                  equals("6"))
                formattedRetVal =
                  formattedRetVal.substring(0,formattedRetVal.length()-2)+" Mb";
              else if ((formattedRetVal.substring(formattedRetVal.length()-1)).
                  equals("3"))
                formattedRetVal =
                  formattedRetVal.substring(0,formattedRetVal.length()-2)+" kb";

              //formattedRetVal = decForm.format(retVal);
              System.out.println("Directory size = " + formattedRetVal);

            }
            else
            {
              helpMsg.append("ERROR: Cannot find the Directory named:");
              helpMsg.append(SYSTEM_LINE_SEPERATOR);
              helpMsg.append(args[i]);
              System.out.println(helpMsg.toString());
            }
          }
        }
        else
        {
          helpMsg.append("ERROR: The dirSize method requires 1");
          helpMsg.append(" directory name to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("capsToSpacesInString"))
      {
        if (args.length >1)
        {
          StringBuffer result = new StringBuffer();
          for (int i=1; i< args.length; i++)
          {
            result.append(capsToSpacesInString(args[i]));
            result.append(" ");
          }
          System.out.println(result.toString().trim());
        }
        else
        {
          helpMsg.append("ERROR: The capsToSpacesInString method requires");
          helpMsg.append(" at least 1 String Argument to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("spacesToCapsInString"))
      {
        if (args.length >1)
        {
          StringBuffer result = new StringBuffer();
          for (int i=1; i< args.length; i++)
          {
            result.append(args[i]);
            result.append(" ");
          }
          System.out.println(spacesToCapsInString(result.toString().trim()));
        }
        else
        {
          helpMsg.append("ERROR: The spacesToCapsInString method requires");
          helpMsg.append(" at least 1 String Argument to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("spacesToCapsInDir"))
      {
        if (args.length >1)
        {
          for (int i=1; i< args.length; i++)
          {
            spacesToCapsInDir(args[i].toString().trim());
          }
        }
        else
        {
          helpMsg.append("ERROR: The spacesToCapsInFilenames method requires");
          helpMsg.append(" at least 1 String Argument to specify the dir to parse for filenames.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("removeParentRelativeReference"))
      {
        if (args.length >1)
        {
          for (int i=1; i< args.length; i++)
          {
            System.out.println(removeParentRelativeReference(args[i].trim()));
          }
        }
        else
        {
          helpMsg.append("ERROR: The removeParentRelativeReference method requires");
          helpMsg.append(" at least 1 path String Argument to operate.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("sleep"))
      {
        if (args.length >1)
        {
          sleep(Integer.parseInt(args[1]));
          //System.out.println(sleep(Integer.parseInt(args[1])));
        }
        else
        {
          helpMsg.append("ERROR: The sleep method requires");
          helpMsg.append(" the sleep time specified in ms.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equalsIgnoreCase("testHexConverters"))
      {
        if (args.length >1)
        {
          int d = 0;
          Vector cmdArgs = new Vector();
          for (int i=1; i< args.length; i++)
          {
            d=Integer.parseInt(args[i]);
            System.out.println("\n----------- "+d+" -----------\n");
            System.out.println("decimalToHexadecimal            : " +decimalToHexadecimal(d));
            System.out.println("convertStringToHex              : " +convertStringToHex(""+d));
            System.out.println("toHEXString                     : " +toHEXString(d) + " ("+convertHexNumberStringToDecimal(toHEXString(d))+")");
          }
        }
        else
        {
          helpMsg.append("ERROR: The testHexConverters method requires");
          helpMsg.append(" at least 1 decimal number to test Convert to HEX.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("executeNativeApp"))
      {
        if (args.length >1)
        {
          Vector cmdArgs = new Vector();
          for (int i=2; i< args.length; i++)
          {
            cmdArgs.add(args[i]);
          }
          System.out.println("\nexecuteNativeApp: Output Sent to std out.");
          boolean verboseScreenOutput = true;
          //executeNativeApp(args[1], cmdArgs, "appOut.txt", verboseScreenOutput);
          System.out.println(executeNativeApp(args[1], cmdArgs, verboseScreenOutput));
          //System.out.println(sleep(Integer.parseInt(args[1])));
        }
        else
        {
          helpMsg.append("ERROR: The executeNativeApp method requires");
          helpMsg.append(" at least a name of an executable to run.");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].startsWith("findFile"))
      {
        if (args.length >1 && args.length <6)
        {
          boolean recurseSubdirs = true;
          boolean regExp = false;
          boolean verbose = true;
          String directory = System.getProperty("user.dir");
          String searchForStr = args[1];
          if (args.length < 3)
          {
            recurseSubdirs = true;
            regExp = false;
            verbose = true;
            directory = System.getProperty("user.dir");
            searchForStr = args[1];
          }
          else if (args.length <4)
          {
            recurseSubdirs = true;
            regExp = false;
            verbose = true;
            directory = args[2];
            searchForStr = args[1];
          }
          else if (args.length <5 )
          {
            recurseSubdirs = Boolean.valueOf(args[3]).booleanValue();
            regExp = false;
            verbose = true;
            directory = args[2];
            searchForStr = args[1];
          }
          else if (args.length <6 )
          {
            recurseSubdirs = Boolean.valueOf(args[3]).booleanValue();
            regExp = Boolean.valueOf(args[4]).booleanValue();
            verbose = true;
            directory = args[2];
            searchForStr = args[1];
          }

          StringBuffer summary = new StringBuffer();
          summary.append((recurseSubdirs?"Recursive search for\n  ":"Search for\n  "));
          summary.append((regExp?"regular expression '":""));
          summary.append(searchForStr);
          summary.append((regExp?"'\n":"\n"));
          summary.append("starting in directory:\n  ");
          summary.append(directory);
          //System.out.println(summary.toString());
          findFile(searchForStr, directory, recurseSubdirs, regExp, verbose );
        }
        else
        {
          helpMsg.append("ERROR: The findFiles method requires");
          helpMsg.append(" at least a filename to find from the recursed current dir.\n\n");
          helpMsg.append("       You can optionally specify the following:\n");
          helpMsg.append("       findFile filename [directoryToStart] [recurse] [regExp]\n");
          helpMsg.append("       directoryToStart is the directory to start looking\n");
          helpMsg.append("       recurse (true or false) to specify if the ");
          helpMsg.append("sub-dirs should be recursed\n");
          helpMsg.append("       regExp  (true or false) to specify if the ");
          helpMsg.append("filename parameter should be trerated as a regular expression\n");
          helpMsg.append(SYSTEM_LINE_SEPERATOR);
          helpMsg.append("       - if using a regExp - the fileToFind param is a quoted Java regExp such as \"[*.png]\" or \"[a-zA-Z*.zip]\"");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      else if (args[0].equals("searchInFile"))
      {
        if (args.length > 2)
        {
          boolean recurseSubdirs = false;
          boolean fileRegExp = false;
          boolean verbose = true;
          String fileName = args[1];
          String searchStr = args[2];

          recurseSubdirs = true;
          fileRegExp = false;
          verbose = true;
          fileName = args[1];
          StringBuffer sb = new StringBuffer(args[2]);
          for (int i = 3; i < args.length; i++)
          {
            sb.append(" ");
            sb.append(args[i]);
          }
          searchStr = sb.toString();
          /*
          else if (args.length <5 )
          {
            recurseSubdirs = Boolean.valueOf(args[3]).booleanValue();
            regExp = false;
            verbose = true;
            directory = args[2];
            searchForStr = args[1];
          }
          else if (args.length <6 )
          {
            recurseSubdirs = Boolean.valueOf(args[3]).booleanValue();
            regExp = Boolean.valueOf(args[4]).booleanValue();
            verbose = true;
            directory = args[2];
            searchForStr = args[1];
          }
          */
          File rootFile = new File(fileName);

          StringBuffer summary = new StringBuffer();
          summary.append((recurseSubdirs?"Recursive search for \"":"Search for \""));
          summary.append(searchStr);
          summary.append("\" starting in file:  ");
          summary.append(fileName);
          if (rootFile != null && !rootFile.isDirectory())
          {
            if(rootFile.canRead())
            {
              String [] ret = searchInFile(searchStr, fileName, true);
              summary.append("\nReturned Lines:");
              for (int i = 0; i < ret.length; i++)
              {
                summary.append(ret[i]);
                summary.append("\n");
              }
            }
          }
          else
          {
            Hashtable retVal =
              searchInFile(searchStr, fileName, recurseSubdirs, fileRegExp, verbose);
            if (retVal != null)
            {
              String currFilename = "";
              Vector lineNums = null;
              summary.append("\nReturned Hashtable:");
              for (Enumeration e = retVal.keys() ; e.hasMoreElements() ;)
              {
                currFilename = (String) e.nextElement();
                summary.append("\n   ");
                summary.append(currFilename);
                summary.append(" -     ");
                lineNums = (Vector) retVal.get(currFilename);
                for (int i = 0; i < lineNums.size(); i++)
                {
                  summary.append(((Integer)lineNums.get(i)).toString());
                  if ( (i + 1) < lineNums.size()) summary.append(", ");
                }
              }
            }
          }
          System.out.println(summary.toString());
        }
        else
        {
          // print searchInFile ERROR msg
        }
      }
      // *****************************************************
      else if (args[0].equals("renameFile"))
      {
        if (args.length > 2)
        {
          boolean verbose = true;
          String fromFilename = args[1];
          String toFilename = args[2];
          if(toFilename.contains(SYSTEM_FILE_SEPERATOR)) toFilename.substring(toFilename.lastIndexOf(SYSTEM_FILE_SEPERATOR));

          String retVal = renameFile(fromFilename, toFilename);
          if (retVal!=null && !"".equals(retVal))
          {
            System.out.println("Successfully renamed file to: "+retVal);
          }
          else
          {
            System.out.println("Error reanming file: "+fromFilename +  " to "+toFilename);
          }
        }
        else
        {
          // print searchInFile ERROR msg
        }
      }
      // *****************************************************
      else if (args[0].equals("zipFile"))
      {
        if (args.length > 1)
        {
          boolean verbose = true;
          String fileName = args[1];

          String zipFilename = compressFileWithZip(fileName);
          if (zipFilename!=null)
          {
            System.out.println("Successfully compressed file: "+zipFilename);
          }
          else
          {
            System.out.println("Error compresing file: "+fileName);
          }
        }
        else
        {
          // print searchInFile ERROR msg
        }
      }
      // *****************************************************
      else if (args[0].equals("removeOldFiles"))
      {
        if (args.length >2)
        {
          removeOldFiles(args[1], Integer.parseInt(args[2]),
            (args.length>3?(args[3]!=null&&args[3].equals(true)?true:false):false));
        }
        else
        {
          helpMsg.append("ERROR: The removeOldFiles method requires 1");
          helpMsg.append(" directory name, 1 number for thee days old and an optional true/false to recurse");
          System.out.println(helpMsg.toString());
        }
      }
      // *****************************************************
      /*
      else if (args[0].equalsIgnoreCase("testGis"))
      {
        if (args.length >2)
        {
          System.out.println(" Looking Up x="+args[1]+"   Y="+args[2]);
          getBCHAssetLatLong(Double.parseDouble(args[1]), Double.parseDouble(args[2]));
        }
        else
        {
          helpMsg.append("ERROR: The testGis method requires an x and a y");
          System.out.println(helpMsg.toString());
        }
      }
      */
      // *****************************************************
      else if (args[0].equals("createCurrentTimeStamp"))
      {
        System.out.println(createCurrentTimeStamp());
      }
      else if (args[0].equals("createCurrentDateTimeStamp"))
      {
        System.out.println(createCurrentDateTimeStamp());
      }
      else
      {
        System.out.println("Unknown Command: "+args[0]);
      }

    }
  }
}