debug.java

华为java接口反编译结果！其中包含其所有接口实现过程

// Decompiled by Jad v1.5.7g. Copyright 2000 Pavel Kouznetsov.
// Jad home page: http://www.geocities.com/SiliconValley/Bridge/8617/jad.html
// Decompiler options: packimports(3) fieldsfirst ansi 
// Source File Name:   Debug.java

package com.huawei.insa2.util;

import java.io.*;
import java.lang.reflect.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.*;

// Referenced classes of package com.huawei.insa2.util:
//            AssertFailed

public class Debug
{

    private static String indentString = "    ";
    private static final String lineSeparator = System.getProperty("line.separator");
    public static PrintWriter out;
    private static final byte hexNumber[] = {
        48, 49, 50, 51, 52, 53, 54, 55, 56, 57, 
        97, 98, 99, 100, 101, 102
    };
    private static SimpleDateFormat sdf = new SimpleDateFormat("HH:mm:ss.SSS");
    public static final String fullInfo = "!@*#~^?'/\"";
    static Class class$com$huawei$insa2$util$Debug; /* synthetic field */
    static Class class$java$lang$String; /* synthetic field */

    private Debug()
    {
    }

    public static final void myAssert(boolean condition)
    {
        if(!condition)
            throw new AssertFailed();
        else
            return;
    }

    public static void setDumpStream(OutputStream os)
    {
        out = new PrintWriter(os);
    }

    public static void setDumpStream(Writer w)
    {
        out = new PrintWriter(w);
    }

    public static void setDumpIndent(String indent)
    {
        indentString = indent;
    }

    public static String getDumpIndent()
    {
        return indentString;
    }

    public static final void dump()
    {
        out.println(dumpHead());
        out.flush();
    }

    public static final void dump(int i)
    {
        out.println(String.valueOf(dumpHead()) + String.valueOf(i));
        out.flush();
    }

    public static final void dump(long l)
    {
        out.println(String.valueOf(dumpHead()) + String.valueOf(l));
        out.flush();
    }

    public static final void dump(float f)
    {
        out.println(String.valueOf(dumpHead()) + String.valueOf(f));
        out.flush();
    }

    public static final void dump(double d)
    {
        out.println(String.valueOf(dumpHead()) + String.valueOf(d));
        out.flush();
    }

    public static final void dump(boolean b)
    {
        out.println(String.valueOf(dumpHead()) + String.valueOf(b));
        out.flush();
    }

    public static final void dump(char ch)
    {
        out.println(String.valueOf(dumpHead()) + String.valueOf(ch));
        out.flush();
    }

    public static final void dump(byte data[], int offset, int length)
    {
        dump(dumpHead(), data, offset, length);
    }

    public static final void dump(byte data[])
    {
        dump(dumpHead(), data);
    }

    public static final void dump(Object obj)
    {
        dump(dumpHead(), 3, new Vector(), obj);
    }

    public static final void dump(Object obj, String prefix)
    {
        dump(String.valueOf(prefix) + String.valueOf(dumpHead()), 3, new Vector(), obj);
    }

    public static final void dump(Object obj, int depth)
    {
        dump(dumpHead(), depth, new Vector(), obj);
    }

    private static final void dump(String prefix, int depth, Vector checkCircuit, Vector v)
    {
        if(v == null)
        {
            dump(prefix, "null");
            return;
        }
        dumpBegin(prefix, checkCircuit, v);
        for(int i = 0; i < v.size(); i++)
        {
            Object item = v.elementAt(i);
            StringBuffer itemPrefix = new StringBuffer();
            itemPrefix.append(indent(prefix));
            itemPrefix.append('[');
            itemPrefix.append(i);
            itemPrefix.append("] ");
            itemPrefix.append(formatClassName(item.getClass(), item));
            itemPrefix.append(" @");
            itemPrefix.append(System.identityHashCode(item));
            dump(itemPrefix.toString(), depth, checkCircuit, item);
        }

        dumpEnd(prefix, checkCircuit, v);
    }

    private static final void dumpServletRequest(String prefix, Object request)
    {
        try
        {
            if(request == null)
            {
                dump(prefix, "null");
                return;
            }
            dumpBegin(prefix, new Vector(), request);
            Class c = request.getClass();
            Method m1 = null;
            m1 = c.getMethod("getParameterNames", new Class[0]);
            String name;
            StringBuffer sb;
            for(Enumeration e = (Enumeration)m1.invoke(request, new Object[0]); e.hasMoreElements(); dump(indent(prefix), String.valueOf(String.valueOf((new StringBuffer(String.valueOf(String.valueOf(name)))).append(" = ").append(sb)))))
            {
                name = e.nextElement().toString();
                Method m2 = c.getMethod("getParameterValues", new Class[] {
                    class$java$lang$String != null ? class$java$lang$String : (class$java$lang$String = class$("java.lang.String"))
                });
                String values[] = (String[])m2.invoke(request, new Object[] {
                    name
                });
                sb = new StringBuffer();
                for(int i = 0; i < values.length; i++)
                {
                    sb.append(values[i]);
                    if(i != values.length - 1)
                        sb.append(" ; ");
                }

            }

            dumpEnd(prefix, new Vector(), request);
        }
        catch(Exception ex)
        {
            ex.printStackTrace(out);
        }
    }

    private static final void dump(String prefix, int depth, Vector checkCircuit, Enumeration e)
    {
        if(e == null)
        {
            dump(prefix, "null");
            return;
        }
        dumpBegin(prefix, checkCircuit, e);
        int i = 0;
        for(; e.hasMoreElements(); dump(String.valueOf(String.valueOf((new StringBuffer(String.valueOf(String.valueOf(indent(prefix))))).append('[').append(i++).append("] "))), depth, checkCircuit, e.nextElement()));
        dumpEnd(prefix, checkCircuit, e);
    }

    private static final void dump(String prefix, Throwable t)
    {
        if(t == null)
        {
            dump(prefix, "null");
            return;
        } else
        {
            dumpBegin(prefix, new Vector(), t);
            t.printStackTrace(out);
            dumpEnd(prefix, new Vector(), t);
            return;
        }
    }

    private static final void dump(String prefix, byte data[], int offset, int length)
    {
        if(data == null)
        {
            dump(prefix, "null");
            return;
        }
        if(offset < 0 || data.length < offset + length)
        {
            dump(prefix, String.valueOf(String.valueOf((new StringBuffer("IndexOutOfBounds:data.length=")).append(data.length).append(" offset=").append(offset).append(" length=").append(length))));
            return;
        }
        dumpBegin(prefix, new Vector(), data);
        int end = offset + length;
        dump(indent(prefix), "[HEX]  0  1  2  3  4  5  6  7  8  9  a  b  c  d  e  f | 0123456789abcdef");
        dump(indent(prefix), "------------------------------------------------------------------------");
        for(int i = offset; i < end; i += 16)
        {
            byte row[] = {
                48, 48, 48, 48, 58, 32, 48, 48, 32, 48, 
                48, 32, 48, 48, 32, 48, 48, 32, 48, 48, 
                32, 48, 48, 32, 48, 48, 32, 48, 48, 32, 
                48, 48, 32, 48, 48, 32, 48, 48, 32, 48, 
                48, 32, 48, 48, 32, 48, 48, 32, 48, 48, 
                32, 48, 48, 32, 124, 32, 46, 46, 46, 46, 
                46, 46, 46, 46, 46, 46, 46, 46, 46, 46, 
                46, 46
            };
            setHex(row, 3, i);
            for(int j = i; j < i + 16; j++)
                if(j < end)
                {
                    int b = data[j];
                    if(b < 0)
                        b += 256;
                    setHex(row, 7 + (j - i) * 3, b);
                    if(b >= 32 && b < 127)
                        row[(56 + j) - i] = (byte)b;
                } else
                {
                    row[6 + (j - i) * 3] = 32;
                    row[7 + (j - i) * 3] = 32;
                    row[56 + (j - i)] = 32;
                }

            dump(indent(prefix), new String(row));
        }

        dumpEnd(prefix, new Vector(), data);
    }

    private static final void dump(String prefix, byte b[])
    {
        dump(prefix, b, 0, b.length <= 512 ? b.length : 512);
    }

    private static final void dump(String prefix, int depth, Vector checkCircuit, Map map)
    {
        if(map == null)
            dump(prefix, "null");
        dumpBegin(prefix, checkCircuit, map);
        for(Iterator i = map.keySet().iterator(); i.hasNext();)
        {
            Object key = i.next();
            Object value = map.get(key);
            if(value instanceof String)
                dump(indent(prefix), String.valueOf(String.valueOf((new StringBuffer(String.valueOf(String.valueOf(key.toString())))).append(" = ").append(value))));
            else
                dump(String.valueOf(String.valueOf((new StringBuffer(String.valueOf(String.valueOf(indent(prefix))))).append(key.toString()).append(" = "))), depth, checkCircuit, map.get(key));
        }

        dumpEnd(prefix, checkCircuit, map);
    }

    private static final void dump(String prefix, String str)
    {
        out.println(String.valueOf(prefix) + String.valueOf(str));
        out.flush();
    }

    private static final void dump(String prefix, int depth, Vector checkCircuit, Object objs[])
    {
        if(objs == null)
        {
            dump(prefix, "null");
            return;
        }
        dumpBegin(prefix, checkCircuit, ((Object) (objs)));
        for(int i = 0; i < objs.length; i++)
            dump(String.valueOf(String.valueOf((new StringBuffer(String.valueOf(String.valueOf(indent(prefix))))).append('[').append(i).append("] "))), depth, checkCircuit, objs[i]);

        dumpEnd(prefix, checkCircuit, ((Object) (objs)));
    }

    private static void dump(String prefix, int depth, Vector checkCircuit, Object obj)
    {
        if(obj == null)
        {
            dump(prefix, "null");
            return;
        }
        try
        {
            if((obj instanceof String) || (obj instanceof Number) || (obj instanceof Character) || (obj instanceof Boolean))
            {
                dump(prefix, obj.toString());
                return;
            }
            if(checkCircuit.contains(new Integer(System.identityHashCode(obj))))
            {
                StringBuffer sb = new StringBuffer();
                sb.append(formatClassName(obj.getClass(), obj));
                sb.append(" @");
                sb.append(System.identityHashCode(obj));
                sb.append(' ');
                dump(prefix, " {Circle recursion!}");