public static synchronized PrintStream getDefaultStream() 
{
        return defaultStream;
}

Return the current default stream for new logs.

 public synchronized OutputStream getOutputStream() 
{
        return logOut;
}

Return the current stream to which output from this log is sent.

 public static LogStream log(String name) 
{
        LogStream stream;
        synchronized (known) {
            stream = (LogStream)known.get(name);
            if (stream == null) {
                stream = new LogStream(name, defaultStream);
            }
            known.put(name, stream);
        }
        return stream;
}

Return the LogStream identified by the given name. If a log corresponding to "name" does not exist, a log using the default stream is created.

 public static int parseLevel(String s) 
{
        if ((s == null) || (s.length() <  1))
            return -1;
        try {
            return Integer.parseInt(s);
        } catch (NumberFormatException e) {
        }
        if (s.length() <  1)
            return -1;
        if ("SILENT".startsWith(s.toUpperCase()))
            return SILENT;
        else if ("BRIEF".startsWith(s.toUpperCase()))
            return BRIEF;
        else if ("VERBOSE".startsWith(s.toUpperCase()))
            return VERBOSE;
        return -1;
}

Convert a string name of a logging level to its internal integer representation.

 public static synchronized  void setDefaultStream(PrintStream newDefault) 
{
        defaultStream = newDefault;
}

Set the default stream for new logs.

 public synchronized  void setOutputStream(OutputStream out) 
{
        logOut = out;
        // Maintain an OutputStreamWriter with default CharToByteConvertor
        // (just like new PrintStream) for writing log message prefixes.
        logWriter = new OutputStreamWriter(logOut);
}

Set the stream to which output from this log is sent.

 public String toString() 
{
        return name;
}

Return log name as string representation.

 public  void write(int b) 
{
        if (b == '\n') {
            // synchronize on "this" first to avoid potential deadlock
            synchronized (this) {
                synchronized (logOut) {
                    // construct prefix for log messages:
                    buffer.setLength(0);;
                    buffer.append(              // date/time stamp...
                        (new Date()).toString());
                    buffer.append(':');
                    buffer.append(name);        // ...log name...
                    buffer.append(':');
                    buffer.append(Thread.currentThread().getName());
                    buffer.append(':'); // ...and thread name
                    try {
                        // write prefix through to underlying byte stream
                        logWriter.write(buffer.toString());
                        logWriter.flush();
                        // finally, write the already converted bytes of
                        // the log message
                        bufOut.writeTo(logOut);
                        logOut.write(b);
                        logOut.flush();
                    } catch (IOException e) {
                        setError();
                    } finally {
                        bufOut.reset();
                    }
                }
            }
        }
        else
            super.write(b);
}

Write a byte of data to the stream. If it is not a newline, then the byte is appended to the internal buffer. If it is a newline, then the currently buffered line is sent to the log's output stream, prefixed with the appropriate logging information.

 public  void write(byte[] b,
    int off,
    int len) 
{
        if (len <  0)
            throw new ArrayIndexOutOfBoundsException(len);
        for (int i = 0; i <  len; ++ i)
            write(b[off + i]);
}

Write a subarray of bytes. Pass each through write byte method.