The Net: Ultimate Internet Guide/WWLCD1.ISO/pc/java/dek17tau/classes/spt/util/stringutil.java

Java Source | 1996-08-14 | 9.2 KB | 356 lines

/*
 * StringUtil.java
 *
 * Copyright (C) 1996 Shaun Terry. All Rights Reserved.
 */

package spt.util;

import java.util.StringTokenizer;
import java.util.Hashtable;
import java.lang.String;
import java.lang.StringBuffer;
import java.lang.Integer;
import java.lang.NumberFormatException;
import java.lang.System;
import java.io.InputStream;
import java.io.DataInput;
import java.io.DataOutput;
import java.io.IOException;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.awt.Color;


/**
 * A variety of String related utility functions.
 *
 * @author Shaun Terry
 */

public class StringUtil {

    /** Convert a delimited String to an array of elements
     *  using the specified delimiter set.
     * @see java.util.StringTokenizer
     */
    static public String[] split(String s, String delimSet) {
        StringTokenizer tok = new StringTokenizer(s, delimSet);
        String s_array[] = new String[ tok.countTokens() ];
        for (int i=0; tok.hasMoreTokens(); ++i) {
            s_array[i] = tok.nextToken();
        }
        return s_array;
    }

    /** Convert a pipe delimited String to an array of elements.
     * @see java.util.StringTokenizer
     */
    static public String[] split(String s) {
        return split(s, "|");
    }

    /** Parse a String and return a Color. The following formats
     *    are recognized: "#FFFFFF", "r,g,b" and one of a number
     *    known case-independent strings (e.g. "red", "black", etc.).
     * @see java.awt.Color
     */
    static public Color stringToColor(String s) {
        if (s.startsWith("#")) {
            // Formatted like #FFFFFF
            try {
                int i = Integer.parseInt(s.substring(1), 16);
                return new Color((i>>16) & 0xFF, (i>>8) & 0xFF, i & 0xFF);
            }
            catch (NumberFormatException e) {
                return null;
            }
        }
        else if (s.length() > 0 && s.charAt(0) >= '0' &&
                                s.charAt(0) <= '9') {
            // Formatted like rrr,ggg,bbb
            String rgb[] = StringUtil.split(s, ",");
            if (rgb.length != 3) return null;
            int c[] = new int[3];
            for (int i=0; i < 3; ++i) {
                try {
                    c[i] = Integer.parseInt(rgb[i].trim());
                }
                catch (NumberFormatException e) {
                    return null;
                }
            }
            return new Color(c[0], c[1], c[2]);
        }
        else if (s.equalsIgnoreCase("white")) return Color.white;
        else if (s.equalsIgnoreCase("lightGray")) return Color.lightGray;
        else if (s.equalsIgnoreCase("gray")) return Color.gray;
        else if (s.equalsIgnoreCase("darkGray")) return Color.darkGray;
        else if (s.equalsIgnoreCase("red")) return Color.red;
        else if (s.equalsIgnoreCase("pink")) return Color.pink;
        else if (s.equalsIgnoreCase("yellow")) return Color.yellow;
        else if (s.equalsIgnoreCase("green")) return Color.green;
        else if (s.equalsIgnoreCase("magenta")) return Color.magenta;
        else if (s.equalsIgnoreCase("cyan")) return Color.cyan;
        else if (s.equalsIgnoreCase("orange")) return Color.orange;
        else if (s.equalsIgnoreCase("black")) return Color.black;
        else if (s.equalsIgnoreCase("blue")) return Color.blue;

        return null;
    }

    /** Convert single string in CGI parameter format to an
     *    array of 2 strings. The 0th element is the parameter name
     *    and the 1st element is the parameter value.
     * @see #cgiParams
     */
    static public String[] cgiParamToStrings(String s) {
        s = s.replace('+', ' ');

        String sn[] = split(s, "=");
        StringBuffer sb[] = new StringBuffer[2];

        for (int i=0; i < 2; ++i) {
            sb[i] = new StringBuffer("");

            int j=0, k;
            while ((k = sn[i].indexOf('%', j)) >= 0) {
                sb[i].append(sn[i].substring(j, k));
                try sb[i].append(
                    (char) Integer.parseInt(sn[i].substring(k+1, k+3), 16));
                catch (NumberFormatException e) {}
                j = k + 3;
            }
            sb[i].append(sn[i].substring(j, sn[i].length()));
        }

        sn[0] = sb[0].toString();
        sn[1] = sb[1].toString();

        return sn;
    }

    /** Read System.in and convert CGI-format parameters to a
     *    Hashtable of name/value pairs. The length of the data to
     *    be read is determined by the property
     *    <strong>CONTENT_LENGTH</strong> (preferably) or, if not
     *    present, by the number of bytes available to read.
     * @see java.util.Hashtable
     * @see java.lang.System#getProperty
     */
    static public Hashtable cgiParams() {
        String s = System.getProperty("CONTENT_LENGTH", "0");
        int cl;
        try cl = Integer.parseInt(s);
        catch (NumberFormatException e) { cl = 0; }

        // if no content length, this *should* work
        if (cl == 0) {
            try cl = System.in.available();
            catch (IOException e) {}
        }

        if (cl > 0) return cgiParams(cl);
        else return null;
    }

    /** Read System.in and convert CGI-format parameters to a
     *    Hashtable of name/value pairs. The length of the data to
     *    be read is determined by content_length.
     * @see java.util.Hashtable
     */
    static public Hashtable cgiParams(int content_length) {
        Hashtable hash = new Hashtable();

        char b[] = new char[content_length];

        for (int i=0; i < content_length; ++i) {
            int c;
            try c = System.in.read();
            catch (IOException e) { continue; }
            if (c < 0) { break; }
            b[i] = (char) c;
        }

        String p = new String(b);
        String params[] = split(p, "&");

        String ss[] = new String[2];
        for (int i=0; i < params.length; ++i) {
            ss = cgiParamToStrings(params[i]);
            hash.put(ss[0], ss[1]);
        }

        return hash;
    }

    /** Write a String to a DataOutput source. Strings are transmitted
     *    as an int, the length, followed by the bytes of the String itself.
     * @see java.io.DataOutput
     */
    static public void writeString(DataOutput d, String s) throws IOException {
        d.writeInt(s.length());
        d.writeBytes(s);
    }

    /** Read a String from a DataInput source. The String must have
     *    been sent by StringUtil.writeString.
     * @see java.io.DataInput
     */
    static public String readString(DataInput d) throws IOException {
        int len = d.readInt();
        if (len == 0) return "";
        byte b[] = new byte[len];
        d.readFully(b);
        return new String(b, 0);
    }

    /** Convert a fractional String to it's decimal
     *    equivalent. e.g. "2 1/4".
     */
    static public float fractionalToFloat(String s) throws NumberFormatException {
        StringTokenizer tok = new StringTokenizer(s, " ");
        float whole = 0;
        if (!tok.hasMoreTokens()) throw new NumberFormatException();

        String p = tok.nextToken();
        if (p.indexOf("/") < 0) {
            whole = Float.valueOf(p).floatValue();
            if (!tok.hasMoreTokens()) return whole;
            p = tok.nextToken();
        }

        StringTokenizer tok2 = new StringTokenizer(p, "/");
        float frac = 0;
        if (tok2.countTokens() != 2) throw new NumberFormatException();

        p = tok2.nextToken();
        frac = Float.valueOf(p).floatValue();
        p = tok2.nextToken();
        frac /= Float.valueOf(p).floatValue();

        if (whole < 0) return whole - frac;
        else return whole + frac;
    }

    /** Create a string initialized with the contents of a file.
     */
    static public String stringFromFile(String file) throws IOException {
        File f = new File(file);

        int len = (int) f.length();
        if (len == 0) return "";

        byte b[] = new byte[len];

        FileInputStream is = new FileInputStream(f);

        is.read(b);

        String s = new String(b, 0);

        is.close();

        return s;
    }

    /** Store a String in its own file.
     */
    static public void toFile(String s, String file) throws IOException {
        FileOutputStream os = new FileOutputStream(file);

        byte b[] = new byte[s.length()];

        s.getBytes(0, s.length(), b, 0);

        os.write(b);

        os.close();
    }

    /** Returns the index of the matching '{', '[' or '(' character
     *    in the given String. The char to be matched must be in
     *    position <code>startAt</code> in the string.
     */
    static public int indexOfMatched(String s, int startAt) {
        int cnt=0;
        char matchChar, c = s.charAt(startAt);

        if (c == '{') matchChar = '}';
        else if (c == '[') matchChar = ']';
        else /*if (c == '(')*/ matchChar = ')';

        for (int i=startAt+1; i < s.length(); ++i) {
            if (s.charAt(i) == matchChar) {
                if (cnt == 0) return i;
                else --cnt;
            }
            else if (s.charAt(i) == c) ++cnt;
        }

        return -1;
    }

    /** Converts a String to a Hashtable. The String must have been
     *    produced by Hastable.toString(). This method converts both
     *    the <em>key</em> and <em>value</em> to objects of type String.
     *    Useful for writing out Hashtables to permanent storage and then
     *    reading them back in.<p>
     *    Warning: This will fail miserably if any of the keys or values have
     *    '=' chars in them.
     * @see java.util.Hashtable#toString()
     */
    static public Hashtable hashtableFromString(String s) {
        Hashtable h = new Hashtable();

        // 5 is the minimum length of a correctly formatted string
        // (e.g. "{A=1}")
        if (s.length() < 5) return h;

        int a=1, b;

        while (true) {
            // Search for the next '='
            b = s.indexOf('=', a);
            String key = s.substring(a, b);

            a = b+1;

            if (s.charAt(a) == '{') {
                // This is a sub-list, parse it out and recursively call
                // ourself

                b = indexOfMatched(s, a);
                h.put(key, hashtableFromString(s.substring(a, b+1)));

                if (s.charAt(b+1) == '}') break;

                a = b+3;
                continue;
            }

            // Search for the last ',' before the next '=' (this way
            // we can handle commas embedded in the string).
            b = s.indexOf('=', a);

            // If there is no next ',' then we're at the end of the list
            // so we just need to find the next '}'
            if (b < 0) b = s.indexOf('}', a);
            else b = s.lastIndexOf(',', b);

            String val = s.substring(a, b);

            h.put(key, val);

            if (s.charAt(b) == '}') break;

            a = b+2;
        }

        return h;
    }
}