tracewriter.java

SAP这个系统的一个转换器

// Decompiled by Jad v1.5.8e2. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://kpdus.tripod.com/jad.html
// Decompiler options: packimports(3) 
// Source File Name:   TraceWriter.java

package com.sap.mw.jco.util;

import com.sap.mw.jco.About;
import com.sap.mw.jco.JCO;
import java.io.*;
import java.text.DateFormat;
import java.text.SimpleDateFormat;
import java.util.Date;

// Referenced classes of package com.sap.mw.jco.util:
//            AboutDialog

public class TraceWriter
    implements com.sap.mw.jco.JCO.TraceListener
{

    private TraceWriter()
    {
        traceFile = null;
        traceWriter = null;
        fTime = new SimpleDateFormat("HH':'mm':'ss':'SSS");
    }

    private void setPath(String path)
    {
        if(traceWriter != null && path != null)
        {
            synchronized(traceWriter)
            {
                traceWriter = createTraceWriter(path);
            }
            writeInfo();
        } else
        if(traceWriter == null)
        {
            traceWriter = createTraceWriter(path);
            writeInfo();
            JCO.addTraceListener(this);
        }
    }

    private Writer createNewFile(File file)
    {
        Writer writer = null;
        try
        {
            try
            {
                FileOutputStream fos = new FileOutputStream(file);
                writer = new OutputStreamWriter(fos, "UTF8");
                (new DataOutputStream(fos)).write(new byte[] {
                    -17, -69, -65
                }, 0, 3);
                fos.flush();
            }
            catch(UnsupportedEncodingException e)
            {
                writer = new OutputStreamWriter(new FileOutputStream(file));
            }
            return writer;
        }
        catch(IOException ex)
        {
            throw new RuntimeException("JCO-TraceWriter: cannot open trace file [" + file.getAbsolutePath() + "]");
        }
    }

    private Writer createTraceWriter(String path)
    {
        Writer traceWriter = null;
        traceFile = null;
        if(path == null)
            path = "stdout";
        if(path.equals("stdout"))
            traceWriter = new OutputStreamWriter(System.out);
        else
        if(path.equals("stderr"))
        {
            traceWriter = new OutputStreamWriter(System.err);
        } else
        {
            if(!(new File(path)).isDirectory())
                path = ".";
            DateFormat fName = new SimpleDateFormat("'JCO'yyMMdd'_'HHmmssSSS");
            StringBuffer traceFileName = new StringBuffer(path);
            traceFileName.append(File.separator);
            traceFileName.append(fName.format(new Date()));
            baseTraceFileName = traceFileName.toString();
            traceFileName.append(".trc");
            traceFile = new File(traceFileName.toString());
            traceWriter = createNewFile(traceFile);
        }
        return traceWriter;
    }

    public static TraceWriter getDefaultTraceWriter()
    {
        synchronized(mutex)
        {
            if(defaultTraceWriter == null)
            {
                defaultTraceWriter = new TraceWriter();
                defaultTraceWriter.traceWriter = defaultTraceWriter.createTraceWriter("stdout");
                defaultTraceWriter.writeInfo();
            }
        }
        return defaultTraceWriter;
    }

    public static String dumpContent(char chars[])
    {
        return dumpContent(chars, true, chars.length);
    }

    public static String dumpContent(char chars[], boolean withHex, int lengthToDump)
    {
        if(chars == null)
            chars = new char[0];
        if(lengthToDump < 0 || lengthToDump > chars.length)
            lengthToDump = chars.length;
        StringBuffer buf = new StringBuffer();
        int offsets[] = new int[8];
        char hexs[] = new char[80];
        for(int i = 0; i < lengthToDump; i += 20)
        {
            buf.append("|");
            for(int k = 0; k < 8; k++)
                offsets[k] = (i / (int)Math.pow(10D, k)) % 10;

            for(int k = 7; k >= 0; k--)
                buf.append(offsets[k]);

            buf.append("|");
            if(withHex)
            {
                for(int k = 0; k < 20; k++)
                    if(i + k < chars.length)
                    {
                        hexs[k * 4 + 0] = HEX[chars[i + k] >> 12 & 0xf];
                        hexs[k * 4 + 1] = HEX[chars[i + k] >> 8 & 0xf];
                        hexs[k * 4 + 2] = HEX[chars[i + k] >> 4 & 0xf];
                        hexs[k * 4 + 3] = HEX[chars[i + k] & 0xf];
                    } else
                    {
                        hexs[k * 4] = hexs[k * 4 + 1] = hexs[k * 4 + 2] = hexs[k * 4 + 3] = ' ';
                    }

                for(int k = 0; k < hexs.length; k++)
                {
                    if(k != 0 && 0 == k % 20)
                        buf.append(' ');
                    buf.append(hexs[k]);
                }

                buf.append('|');
            }
            for(int k = 0; k < 20; k++)
            {
                char curChar = i + k >= chars.length ? ' ' : chars[i + k];
                buf.append(Character.isISOControl(curChar) || !Character.isDefined(curChar) ? '.' : curChar);
            }

            buf.append('|');
            buf.append(LF);
        }

        return buf.toString();
    }

    public static String dumpContent(byte bytes[])
    {
        return dumpContent(bytes, bytes.length);
    }

    public static String dumpContent(byte bytes[], int lengthToDump)
    {
        if(bytes == null)
            bytes = new byte[0];
        if(lengthToDump < 0 || lengthToDump > bytes.length)
            lengthToDump = bytes.length;
        StringBuffer buf = new StringBuffer();
        int offsets[] = new int[8];
        char hexs[] = new char[80];
        for(int i = 0; i < lengthToDump; i += 40)
        {
            buf.append("|");
            for(int k = 0; k < 8; k++)
                offsets[k] = (i / (int)Math.pow(10D, k)) % 10;

            for(int k = 7; k >= 0; k--)
                buf.append(offsets[k]);

            buf.append("|");
            for(int k = 0; k < 40; k++)
                if(i + k < bytes.length)
                {
                    hexs[k * 2 + 0] = HEX[bytes[i + k] >> 4 & 0xf];
                    hexs[k * 2 + 1] = HEX[bytes[i + k] & 0xf];
                } else
                {
                    hexs[k * 2] = hexs[k * 2 + 1] = ' ';
                }

            for(int k = 0; k < hexs.length; k++)
            {
                if(k != 0 && 0 == k % 20)
                    buf.append(' ');
                buf.append(hexs[k]);
            }

            buf.append('|');
            buf.append(LF);
        }

        return buf.toString();
    }

    public static void start(String path)
    {
        synchronized(mutex)
        {
            if(self == null)
                self = new TraceWriter();
            self.setPath(path);
        }
    }

    public static void stop()
    {
        synchronized(mutex)
        {
            if(self == null)
                return;
            JCO.removeTraceListener(self);
            if(self.traceWriter != null)
                try
                {
                    self.traceWriter.close();
                }
                catch(Exception ex) { }
            self = null;
        }
    }

    public void trace(int message_level, String message)
    {
        try
        {
            synchronized(traceWriter)
            {
                if(traceFile != null && traceFile.length() > 0x1400000L)
                {
                    traceWriter.close();
                    String traceFileName = baseTraceFileName + '.' + ++files_count + ".trc";
                    traceFile = new File(traceFileName.toString());
                    traceWriter = createNewFile(traceFile);
                }
                traceWriter.write(Thread.currentThread().getName());
                traceWriter.write(" [");
                traceWriter.write(fTime.format(new Date()));
                traceWriter.write("]");
                traceWriter.write(": ");
                traceWriter.write(message);
                traceWriter.write(CRLF);
                traceWriter.flush();
            }
        }
        catch(IOException ex)
        {
            throw new RuntimeException("TraceWriter.trace(): " + ex.toString());
        }
    }

    private void writeInfo()
    {
        if(traceWriter == null)
        {
            return;
        } else
        {
            (new About()).printTo(new PrintWriter(traceWriter));
            trace(0, "********************  " + new Date() + "   ***************************");
            return;
        }
    }

    protected void finalize()
    {
        JCO.removeTraceListener(this);
        if(traceWriter != null)
            try
            {
                traceWriter.close();
            }
            catch(Exception ex) { }
    }

    public static void main(String args[])
    {
    }

    private static final String CRLF = System.getProperty("line.separator");
    private static TraceWriter self = null;
    private static TraceWriter defaultTraceWriter = null;
    private static String baseTraceFileName = null;
    private static int files_count = 0;
    private static final int MAX_TRACE_FILE_LENGTH = 0x1400000;
    private File traceFile;
    private Writer traceWriter;
    private DateFormat fTime;
    private static final char HEX[] = {
        '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 
        'A', 'B', 'C', 'D', 'E', 'F'
    };
    private static final String LF = System.getProperty("line.separator");
    private static Object mutex = new Object();

}