Quadcap Embeddable Server

com/quadcap/util/Util.java

Go to the documentation of this file.

package com.quadcap.util;

/* Copyright 1997 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

//-//#ifdef JDK11
//-import com.sun.java.util.collections.ArrayList;
//-import com.sun.java.util.collections.Collections;
//-import com.sun.java.util.collections.Comparator;
//#endif

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.Hashtable;
import java.util.List;
import java.util.Properties;
import java.util.Vector;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.PrintStream;

import java.text.Collator;

import java.lang.reflect.Array;

/**
 * This class aggregates a bunch of various string manipulation utilities.
 *
 * @author Stan Bailes
 */
public class Util {
    /**
     * Split a string into a vector of elements.
     */
    public static Vector split(String s, char delim) {
        return split(s, delim, -1);
    }
    
    public static Vector split(String s, char delim, int cnt) {
        Vector v = new Vector();
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            if (c == delim && (cnt < 0 || v.size()+1 < cnt)) {
                if (sb.length() > 0) {
                    v.addElement(sb.toString());
                    sb = new StringBuffer();
                }
            } else {
                sb.append(c);
            }
        }
        if (sb.length() > 0) {
            v.addElement(sb.toString());
        }
        while (v.size() < cnt) {
            v.addElement(new String(""));
        }
        return v;   
    }

    public static Hashtable parseArgs(String args[]) {
        Hashtable t = new Hashtable();
        int i = 0;
        Vector a = new Vector();
        while (i < args.length && args[i].startsWith("-")) {
            String arg = args[i];
            if (arg.charAt(0) == '-') {
                Vector v = (Vector)t.get(arg);
                if (v == null) v = new Vector();
                v.addElement(args[i+1]);
                t.put(arg.substring(1), v);
                i++;
            } else {
                a.addElement(arg);
            }
            i++;
        }
        t.put("", a);
        return t;
    }

    public static String readFile(String filename) {
        File f = new File(filename);
        if (f.exists()) {
            try {
                FileInputStream is = new FileInputStream(f);
                StringBuffer sb = new StringBuffer();
                int c;
                while ((c = is.read()) >= 0) sb.append((char)c);
                String r = sb.toString();
                return r;
            } catch (IOException e) {
                Debug.println("Util.readFile(" + filename + ") " +
                              "Got IOException: " + e.toString());
            }
        }
        return null;
    }

    public static char[] hexMap = {'0', '1', '2', '3', '4', '5', '6', '7',
                            '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'};
    
    public static String strBytes(byte[] buf, int offset, int len) {
        if (buf == null || len == 0) return "<null>";
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < len; i++) {
            if ((i % 16) == 0 && (len - i > 12 || i > 0)) {
                if (i > 0) {
                    sb.append(' ');
                    sb.append(' ');
                    for (int j = (i-1) & ~15; j < i; j++) {
                        byte c = buf[offset + j];
                        if (c >= 0x20 && c <= 0x7f) sb.append((char)c);
                        else sb.append('.');
                    }
                }
                sb.append('\n');
            }
            byte b = buf[offset+i];
            sb.append(hexMap[(b >> 4) & 0xf]);
            sb.append(hexMap[b & 0xf]);
            sb.append(' ');
        }
        if (len > 16) for (int j = len; (j&15) != 0; j++) sb.append("   ");
        sb.append("  ");
        for (int j = (len-1) & ~15; j < len; j++) {
            byte c = buf[offset + j];
            if (c >= 0x20 && c <= 0x7f) sb.append((char)c);
            else sb.append('.');
        }
        return sb.toString();    
    }

    public static String hexBytes(byte[] buf) {
        if (buf == null) return "<null>";
        return hexBytes(buf, 0, buf.length);
    }

    public static String hexBytes(byte[] buf, int off, int len) {
        if (buf == null) return "<null>";
        StringBuffer sb = new StringBuffer();
        for (int i = off; i < off + len; i++) {
            if (i >= buf.length) {
                sb.append("###### OVERRUN ######");
                break;
            }
            byte b = buf[i];
            sb.append(hexMap[(b >> 4) & 0xf]);
            sb.append(hexMap[b & 0xf]);
        }
        return sb.toString();
    }

    public static String hexInts(byte[] buf) {
        return hexInts(buf, 0, buf.length);
    }
    
    public static String hexInts(byte[] buf, int off, int len) {
        if (buf == null) return "<null>";
        StringBuffer sb = new StringBuffer();
        for (int i = off; i < off + len; i++) {
            if (i >= buf.length) {
                sb.append("###### OVERRUN ######");
                break;
            }
            byte b = buf[i];
            sb.append(hexMap[(b >> 4) & 0xf]);
            sb.append(hexMap[b & 0xf]);
            if ((((i+1) - off) % 4) == 0) sb.append(' ');
        }
        return sb.toString();
    }

    public static String strBytes(byte[] buf) {
        if (buf == null) return "<null>";
        return strBytes(buf, 0, buf.length);
    }

    public static boolean boolProperty(String s) {
        return Boolean.getBoolean(s);
    }

    public static int intProperty(String s, int defVal) {
        String v = System.getProperty(s);
        return v == null ? defVal : Integer.parseInt(v);
    }

    public static String strProperty(String s, String defVal) {
        String v = System.getProperty(s);
        return v == null ? defVal : v;
    }
    public static byte[] bytes(String s) {
        byte[] buf = new byte[s.length()];
        s.getBytes(0, buf.length, buf, 0);
        return buf;
    }

    /**
     * To hell with character encodings ;-)
     */
    public static byte[] strCharsAsBytes(String s) {
        byte[] buf = new byte[s.length() * 2];
        char[] cbuf = s.toCharArray();
        charsToBytes(cbuf, 0, buf, 0, s.length());
        return buf;
    }

    public static void bytesToChars(byte[] bbuf, int boff,
                                    char[] cbuf, int coff, int clen) {
        int clim = coff + clen;
        while (coff < clim) {
            int c1 = bbuf[boff++] & 0xff;
            int c2 = bbuf[boff++] & 0xff;
            cbuf[coff++] = (char)((c1 << 8) | c2);
        }
    }

    public static void charsToBytes(char[] cbuf, int coff,
                                    byte[] bbuf, int boff, int clen) {
        int clim = coff + clen;
        while (coff < clim) {
            char c = cbuf[coff++];
            bbuf[boff++] = (byte)(c >> 8);
            bbuf[boff++] = (byte)(c & 0xff);
        }
    }

    /**
     * Convert an int to a byte array, MSB first
     *
     * @param i the int value
     */
    public static byte[] bytes(int i) {
        byte[] buf = new byte[4];
        buf[0] = (byte)((i >> 24) & 0xff);
        buf[1] = (byte)((i >> 16) & 0xff);
        buf[2] = (byte)((i >>  8) & 0xff);
        buf[3] = (byte)((i >>  0) & 0xff);
        return buf;
    }

    /**
     * Convert a long to a byte array, MSB first.
     *
     * @param i the long value
     */
    public static byte[] bytes(long i) {
        byte[] buf = new byte[8];
        buf[0] = (byte)((i >> 56) & 0xff);
        buf[1] = (byte)((i >> 48) & 0xff);
        buf[2] = (byte)((i >> 40) & 0xff);
        buf[3] = (byte)((i >> 32) & 0xff);
        buf[4] = (byte)((i >> 24) & 0xff);
        buf[5] = (byte)((i >> 16) & 0xff);
        buf[6] = (byte)((i >>  8) & 0xff);
        buf[7] = (byte)((i >>  0) & 0xff);
        return buf;
    }

    /**
     * Convert a byte array which represents an integer into an integer.
     *
     * @param buf the byte array, MSB first.
     * @return the integer value stored in the byte array.
     */
    public static int integer(byte[] buf) {
        int ret = 0;
        for (int i = 0; i < buf.length; i++) {
            ret <<= 8;
            ret |= (buf[i] & 0xff);
        }
        return ret;
    }

    /**
     * Extract an integer from four bytes in a byte array.
     *
     * @param buf the byte array
     * @param pos the offset in the array of the first (MSB) byte of the int
     * @return the integer value stored in the byte array.
     */
    public static int integer(byte[] buf, int pos) {
        int b1 = buf[pos++] & 0xff;
        int b2 = buf[pos++] & 0xff;
        int b3 = buf[pos++] & 0xff;
        int b4 = buf[pos++] & 0xff;
        int val = (b1 << 24) + (b2 << 16) + (b3 << 8) + (b4 << 0) ;
        return val;
    }

    public static void putInt(byte[] buf, int pos, int val) {
        buf[pos++] = (byte)((val >>> 24) & 0xff);
        buf[pos++] = (byte)((val >>> 16) & 0xff);
        buf[pos++] = (byte)((val >>>  8) & 0xff);
        buf[pos]   = (byte)((val       ) & 0xff);
    }

    public static void putLong(byte[] buf, int pos, long val) {
        buf[pos++] = (byte)((val >>> 56) & 0xff);
        buf[pos++] = (byte)((val >>> 48) & 0xff);
        buf[pos++] = (byte)((val >>> 40) & 0xff);
        buf[pos++] = (byte)((val >>> 32) & 0xff);
        buf[pos++] = (byte)((val >>> 24) & 0xff);
        buf[pos++] = (byte)((val >>> 16) & 0xff);
        buf[pos++] = (byte)((val >>>  8) & 0xff);
        buf[pos]   = (byte)((val       ) & 0xff);
    }

    /**
     * Convert a byte array which represents a long into a long.
     *
     * @param buf the byte array, MSB first.
     * @return the long value stored in the byte array.
     */
    public final static long bytesToLong(byte[] buf) {
        return bytesToLong(buf, 0);
    }

    /**
     * Convert a byte array which represents a long into a long.
     *
     * @param buf the byte array, MSB first.
     * @return the long value stored in the byte array.
     */
    public final static long bytesToLong(byte[] buf, int offset) {
        long ret = 0;
        int lim = offset + 8;
        for (int i = offset; i < buf.length && i < lim; i++) {
            ret <<= 8;
            ret |= (buf[i] & 0xff);
        }
        return ret;
    }

    /**
     * Byte-array comparison.
     *
     * @param k1 the byte array containing key 1.
     * @param s1 the starting offset of key 1 in <code>k1</code>.
     * @param c1 the length of key 1.
     * @param k2 the byte array containing key 2.
     * @param s2 the starting offset of key 2 in <code>k2</code>.
     * @param c2 the length of key 2.
     * @return<p><table cellspacing=2 border=2>
     *          <tr><td>&lt; zero<td>if key1 is less than key2
     *          <tr><td>zero<td>if key1 is equal to key2
     *          <tr><td>&gt; zero<td>if key1 is greater than key2</table>
     */
    public static int compareBytes(byte[] k1, int s1, int c1,
                            byte[] k2, int s2, int c2)
    {
        int l1 = s1 + c1;
        int l2 = s2 + c2; 
        while (s1 < l1 && s2 < l2) {
            if (k1[s1] < k2[s2]) return -1;
            if (k1[s1] > k2[s2]) return 1;
            s1++;
            s2++;
        }
        if (c1 < c2) return -1;
        if (c1 > c2) return 1;
        return 0;
    }

    public static int compareBytes(byte[] b1, byte[] b2) {
        return compareBytes(b1, 0, b1.length, b2, 0, b2.length);
    }

    /**
     * Return a File object corresponding to the specified file name.
     * If the name is relative, it is located relative to the user's
     * current directory.  This is helpful for the case when we run
     * as a service from the /winnt/system32 directory and want to
     * open files relative to our install root.
     *
     * @param name the file name
     * @return the file
     */
    public static File userFile(String name) {
        File f = new File(name);
        f = new File(f.getAbsolutePath());
        return f;
    }

    /**
     * Like File.list(), but returns directories first, and sorts alpha
     */
    public static String[] listFiles(final File f) {
        String[] s = f.list();
        if (s != null) {
            final Collator col = Collator.getInstance();
            Comparator c = new Comparator() {
                public int compare(Object a, Object b) {
                    File fa = new File(f, a.toString());
                    File fb = new File(f, b.toString());
                    if (fa.isDirectory() && !fb.isDirectory()) return -1;
                    if (!fa.isDirectory() && fb.isDirectory()) return 1;
                    return col.compare(a.toString(), b.toString());
                }
                public boolean equals(Object obj) { return false; }
            };
            ArrayList a = new ArrayList();
            for (int i = 0; i < s.length; i++) a.add(s[i]);
            Collections.sort(a, c);
            for (int i = 0; i < s.length; i++) s[i] = (String)a.get(i);
        }
        return s;
    }

    public static String getStackTrace(Throwable t) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(bos);
        t.printStackTrace(ps);
        ps.flush();
        return bos.toString();
    }

    static HashMap traces = new HashMap();
    static int lastTrace = 0;

    /**
     * Return a string showing the current stack trace.
     */
    public static String stackTrace() {
        return stackTrace(new Exception(""), true);
    }

    public static String stackTrace(boolean condense) {
        return stackTrace(new Exception(""), condense);
    }

    /**
     * Return a string showing the current stack trace.
     */
    public static String stackTrace(Throwable e, boolean condense) {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        PrintStream ps = new PrintStream(bos);
        e.printStackTrace(ps);
        ps.flush();
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        StringBuffer sb = new StringBuffer();
        int state = 1;
        while (state >= 0) {
            int c = bis.read();
            if (c < 0) state = -1;
            switch (state) {
            case -1:
                break;
            case 0:
                if (c == '\n') state++;
                break;
            case 1:
                if (c == '\n') state++;
                break;
            case 2:
                if (c == 'a') state++;
                break;
            case 3:
                if (c == 't') state++;
                break;
            case 4:
                if (c == ' ') state++;
                break;
            case 5:
                sb.append((char)c);
                if (c == '\n') state = 2;
                break;
            }
        }
        String s = sb.toString();
        Integer num = (Integer)traces.get(s);
        if (num == null) {
            num = new Integer(++lastTrace);
            traces.put(s, num);
            s = "Trace " + num + ": " + s;
        } else {
            s = "Trace " + num + (condense ? "" : (": " + s));
        }
        return s;
    }

    public static void copyStream(InputStream in, OutputStream out) 
        throws IOException 
    {
        byte[] buf = new byte[4096];
        int cnt;
        while ((cnt = in.read(buf)) > 0) out.write(buf, 0, cnt);
    }

    public static int execCommand(String cmd,
                                  OutputStream out, OutputStream err) {
        int ret = -1;
        try {
            Runtime r = Runtime.getRuntime();
            Process p = r.exec(cmd);
            return waitFor(p, out, err);
        } catch (IOException e) {
            Debug.print(e);
            ret = -1;
        }
        return ret;
    }

    public static int execCommand(String[] cmdarray,
                                  OutputStream out, OutputStream err) {
        int ret = -1;
        try {
            Runtime r = Runtime.getRuntime();
            Process p = r.exec(cmdarray);
            return waitFor(p, out, err);
        } catch (IOException e) {
            Debug.print(e);
            ret = -1;
        }
        return ret;
    }

    public static int waitFor(Process p, OutputStream out,
                              OutputStream err) throws IOException {
        Thread it = makeCopyThread(p.getInputStream(), out);
        Thread et = makeCopyThread(p.getErrorStream(), err);
        it.start();
        et.start();
        int ret = Util.waitFor(p);
        Util.join(it);
        Util.join(et);
        return ret;
    }

    
        
    public static int execCommand(String cmd, OutputStream out) {
        return execCommand(cmd, out, out);
    }

    public static String execCommand(String cmd) {
        ByteArrayOutputStream b = new ByteArrayOutputStream();
        execCommand(cmd, b);
        return b.toString();
    }
            
    public static String execCommand(String[] cmd) {
        ByteArrayOutputStream b = new ByteArrayOutputStream();
        execCommand(cmd, b, b);
        return b.toString();
    }
            
    public static String execCommand(String a, String b) {
        return execCommand(new String[]{a, b});
    }
    public static String execCommand(String a, String b, String c) {
        return execCommand(new String[]{a, b, c});
    }
            
    /**
     * Create a thread which copies bytes from an input stream to
     * an output stream until end of file is reached.
     */
    public static Thread makeCopyThread(final InputStream in,
                                        final OutputStream out) {
        Thread t = new Thread() {
            boolean terminate = false;
            public void run() {
                int c;
                try {
                    while (!terminate && (c = in.read()) >= 0) out.write(c);
                } catch (IOException e) {
                    Debug.print(e);
                }
            }
            public void terminate() {
                this.terminate = true;
            }
        };
        return t;
    }

    /**
     * Utility to sleep without having to worry about catching
     * InterruptedException.
     *
     * @param ms milliseconds to sleep.
     */
    public static final void sleep(long ms) {
        try {
            Thread.sleep(ms);
        } catch (InterruptedException e) {
            Debug.print(e);
        }
    }

    /**
     * Utility to join without having to worry about catching
     * InterruptedException.
     *
     * @param t the thread to wait for
     */
    public static final void join(Thread t) {
        try {
            t.join();
        } catch (InterruptedException e) {
            Debug.print(e);
        }
    }

    /**
     * Utility to wait for a process without having to worry about catching
     * InterruptedException
     *
     * @param p the process to wait for
     */
    public static final int waitFor(Process p) {
        try {
            return p.waitFor();
        } catch (InterruptedException e) {
            Debug.print(e);
            return -1;
        }
    }
    
    /**
     * Parse a semicolon-separated property list:
     *
     * prop1=val1;prop2=val2
     */
    public static final Properties parsePropsString(String extraProps) {
        Properties props = new Properties();
        Vector v = Util.split(extraProps, ';');
        for (int i = 0; i < v.size(); i++) {
            String prop = v.elementAt(i).toString();
            int idx = prop.indexOf('=');
            if (idx > 0) {
                props.setProperty(prop.substring(0, idx),
                                  prop.substring(idx+1));
            }
        }
        return props;
    }

    /**
     * Generic array resizer
     */
    public static Object checkCapacity(Object array, int desiredcap) {
        int len = Array.getLength(array);
        if (len < desiredcap) {
            Class c = array.getClass();
            Class t = c.getComponentType();
            Object n = Array.newInstance(t, desiredcap);
            System.arraycopy(array, 0, n, 0, len);
            array = n;
        }
        return array;
    }

    /**
     * Parse a comma-separated list of integers or integer ranges.
     *
     * Example:  1,2
     * Example:  1,3-5,77
     *
     * @return a List of Integers
     */
    public static List parseIntList(String s) {
        List ret = new ArrayList();
        List tests = Util.split(s, ',');

        for (int i = 0; i < tests.size(); i++) {
            int first, last;
            final String t = tests.get(i).toString();
            final int idx = t.indexOf('-');
            if (idx > 0) {
                first = Integer.parseInt(t.substring(0, idx));
                last = Integer.parseInt(t.substring(idx+1));
                if (last < first) last = first;
            } else {
                first = last = Integer.parseInt(t);
            }
            for (int test = first; test <= last; test++) {
                ret.add(new Integer(test));
            }
        }
        return ret;
    }

    public static int compareObjects(Object a, Object b) {
        if (a == null) {
            return  (b == null) ? 0 : -1;
        } else if (b == null) {
            return 1;
        } else if (a instanceof Comparable) {
            return ((Comparable)a).compareTo(b);
        } else if (b instanceof Comparable) {
            return 0 - ((Comparable)b).compareTo(a);
        } else {
            return String.valueOf(a).compareTo(String.valueOf(b));
        }
    }

    public static String htmlEscape(String s) {
        StringBuffer sb = new StringBuffer();
        for (int i = 0; i < s.length(); i++) {
            char c = s.charAt(i);
            switch (c) {
            case '<': sb.append("&lt;"); break;
            case '>': sb.append("&gt;"); break;
            case '&': sb.append("&amp;"); break;
            default: sb.append(c); break;
            }
        }
        return sb.toString();
    }
    
}