x.java

爬虫

package st.ata.util;

import java.io.PrintWriter;
import java.io.StringWriter;
import java.lang.reflect.UndeclaredThrowableException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.logging.Level;
import java.util.logging.Logger;

// Tested by TestX.java

/** A collection of useful static methods. */

public final class X {
    public static final int DEBUG = 2;

    /** Throws a runtime exception with message <code>m</code>. */
    public static void fail(String m) {
        RuntimeException e = new RuntimeException(m);
        popTrace(e, 1);
        throw e;
    }

    /**
     * Throws a runtime exception with message <code>systemProperty</code>.
     * @param systemProperty a <code>String</code> value which specifies
     *        a boolean system property, which if true will cause
     *        an exception to be thrown.
     */
    public static void testFailure(String systemProperty) {
        if (!Boolean.getBoolean(systemProperty)) {
            return;
        }

        RuntimeException e = new RuntimeException(systemProperty);
        popTrace(e, 1);
        throw e;
    }

    /** Throws a runtime exception if <code>b</code> is not true. */
    public static void check(boolean b) {
        if (b) return;
        RuntimeException e = new RuntimeException("assertion failure");
        popTrace(e, 1);
         throw e;
    }

    /** Throws a runtime exception if <code>b</code> is not true. */
    public static void check(boolean b, String m) {
        if (b) return;
        RuntimeException e = new RuntimeException(m);
        popTrace(e, 1);
        throw e;
    }

    /** Throws an illegal argument exception if <code>b</code> is not true. */
    public static void checkargs(boolean b) {
        if (b) return;
        RuntimeException e = new IllegalArgumentException();
        popTrace(e, 1);
        throw e;
    }

    /** Throws an illegal state exception if <code>b</code> is not true. */
    public static void checkstate(boolean b) {
        if (b) return;
        RuntimeException e = new IllegalStateException();
        popTrace(e, 1);
        throw e;
    }

    /**
     *  Returns an {@link UndeclaredThrowableException}
     *  wrapping <code>e</code>.
     */

    public static RuntimeException toRTE(Exception e) {
        RuntimeException rte = new UndeclaredThrowableException(e);
        popTrace(rte, 1);
        return rte;
    }

    /** Same as <c>ut(b,&nbsp;"")</c>. */
    public static void ut(boolean b) { ut(b, ""); }

    /** Test condition during unit testing.  If <c>b</c> is true, does
    nothing.  If <c>b</c> is not true, prints (to
    <c>System.out</c>)
    <c>"Unit&nbsp;test&nbsp;failure:&nbsp;"&nbsp;+&nbsp;m</c> and
    a stack trace then returns. */
    public static void ut(boolean b, String m) {
    if (! b) {
        try {
                if (b) return;
                RuntimeException e
                    = new RuntimeException("Unit test failure: " + m);
                popTrace(e, 1);
                throw e;
        } catch (RuntimeException e) {
        System.out.println("");
        e.printStackTrace(System.out);
        }
    }
    }
    /**
     * print out the programName and arguments used
     */
    public static void printArgs(String programName, String[] args) {
        System.out.print(programName);
        for (int i=0; i<args.length; i++){
            System.out.print(" ");
            System.out.print(args[i]);
        }
    }
    public static void noimpl() {
        RuntimeException e = new RuntimeException("Not implemented yet.");
        popTrace(e, 1);
        throw e;
    }

    /** Returns a full description of a {@link Throwable}.  This full
     *  description includes a stack trace.  This method will never
     *  throw an error or exception: if something bad happens, it
     *  simply returns null. */
    public static String getFullDescription(Throwable t) {
        try {
            StringWriter sw = new StringWriter();
            PrintWriter o = new PrintWriter(sw);
            t.printStackTrace(o);
            o.flush();
            return sw.toString();
        } catch (Throwable ignore) { return null; }
    }

    /** Removes the top <code>n</code> stack-trace elements from
     *  <code>t</code>.  This is useful inside methods like {@link
     *  #fail} to help debuggers more quickly identify the location of
     *  a failure. */
    public static void popTrace(Throwable t, int n) {
        /*StackTraceElement[] ot = t.getStackTrace();
        int len = ot.length - n;
        StackTraceElement[] nt = new StackTraceElement[len];
        System.arraycopy(ot, n, nt, 0, len);
        t.setStackTrace(nt);*/
    }

    public static int decodeInt(byte[] buf, int offset) {
        return ((buf[offset+3]&0xff)<<24
                | (buf[offset+2]&0xff)<<16
                | (buf[offset+1]&0xff)<<8
                | (buf[offset]&0xff));
    }

    public static int decodeShort(byte[] buf, int offset) {
        return ((buf[offset+1]&0xff)<<8
                | (buf[offset]&0xff));
    }

    public static void encodeShort(byte[] buf, int offset, int val) {
        X.check(val<=Short.MAX_VALUE && val>=Short.MIN_VALUE);
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset] = (byte)val;
    }

    public static void encodeInt(byte[] buf, int offset, int val) {
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset] = (byte)val;
    }

    public static long decodeLong(byte[] buf, int offset) {
        long lo = decodeInt(buf, offset) & 0xffffffffL;
        long hi = decodeInt(buf, offset+4);
        return (hi<<32) | lo;
    }

    public static void encodeLong(byte[] buf, int offset, long val) {
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset++] = (byte)val; val >>= 8;
        buf[offset] = (byte)val;
    }


    /**
     *  returns the printable representation of <code>data</code>
     *  after escaping non-printable characters in C style.
     */
    public static String printable(byte[] data) {
        return printable(data, 0, data.length);
    }

    /**
     *  returns the printable representation of <code>data</code>
     *  from <code>start</code> (inclusive) to <code>end</code> (exclusive).
     *  after escaping non-printable characters in C style.
     *  <code>data</code> may not be <code>null</code> and
     *  <code>start</code> must be smaller or equal to <code>end</code>
     *  Both <code>start</code> and <code>end</code> are bounded by
     *  <code>0</code> and <code>data.length</code> bot inclusive.
     */

    public static String printable(byte[] data, int start, int end) {
        checkargs(data != null);
        checkargs(start <= end);
        checkargs(start >= 0);
        checkargs(end <= data.length);
        StringBuffer sb = new StringBuffer();

        for (int i = start; i < end; i++) {
            final byte b = data[i];
            if (b < 0x20 || b > 0x7e) {
                switch (b) {
                case '\r':
                    sb.append("\\r");
                    break;
                case '\n':
                    sb.append("\\n");
                    break;
                case '\t':
                    sb.append("\\t");
                    break;
                case '\b':
                    sb.append("\\b");
                    break;
                case '\f':
                    sb.append("\\f");
                    break;
                case '\\':
                    sb.append("\\\\");
                    break;
                default:
                    sb.append('\\');
                    sb.append(b >>> 6);
                    sb.append((b >>> 3) & 0x07);
                    sb.append(b & 0x07);
                    break;
                }
            } else {
                sb.append((char)b);
            }
        }
        return sb.toString();
    }

    public static void log(String ctxt, Level level, String msg, Throwable t) {
        Logger.getLogger("st."+ctxt).log(level,  ctxt+": "+msg, t);
    }
    public static void log(String ctxt, Level level, String msg) {
        Logger.getLogger("st."+ctxt).log(level, ctxt+": "+msg);
    }
    public static ArrayList dupElim(ArrayList al, Comparator cm) {
        if (al.size()<2)
            return al;
        Collections.sort(al, cm);
        Object prev =  al.get(0);
        ArrayList n = new ArrayList();
        n.add(prev);
        for (int i = 1; i < al.size(); i++) {
            if (!prev.equals(al.get(i)))
                n.add(al.get(i));
            prev =  al.get(i);
        }
        return n;
    }

}