File	Doc	Category	Size	Date	Package
LogStream.java	API Doc	Java SE 5 API	6752	Fri Aug 26 14:57:12 BST 2005	java.rmi.server

LogStream

• java.lang.Object
  • java.io.OutputStream
    • java.io.FilterOutputStream
      • java.io.PrintStream

Fields Summary
private static Hashtable	known table mapping known log names to log stream objects
private static PrintStream	defaultStream default output stream for new logs
private String	name log name for this log
private OutputStream	logOut stream where output of this log is sent to
private OutputStreamWriter	logWriter string writer for writing message prefixes to log stream
private StringBuffer	buffer string buffer used for constructing log message prefixes
private ByteArrayOutputStream	bufOut stream used for buffering lines
public static final int	SILENT log level constant (no logging).
public static final int	BRIEF log level constant (brief logging).
public static final int	VERBOSE log level constant (verbose logging).

Constructors Summary

private LogStream(String name, OutputStream out) Create a new LogStream object. Since this only constructor is private, users must have a LogStream created through the "log" method. param name string identifying messages from this log out output stream that log messages will be sent to since JDK1.1 deprecated no replacement super(new ByteArrayOutputStream()); bufOut = (ByteArrayOutputStream) super.out; this.name = name; setOutputStream(out);

Methods Summary
public static synchronized java.io.PrintStream	getDefaultStream() Return the current default stream for new logs. return default log stream see #setDefaultStream since JDK1.1 deprecated no replacement return defaultStream;
public synchronized java.io.OutputStream	getOutputStream() Return the current stream to which output from this log is sent. return output stream for this log see #setOutputStream since JDK1.1 deprecated no replacement return logOut;
public static java.rmi.server.LogStream	log(java.lang.String name) 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. param name name identifying the desired LogStream return log associated with given name since JDK1.1 deprecated no replacement LogStream stream; synchronized (known) { stream = (LogStream)known.get(name); if (stream == null) { stream = new LogStream(name, defaultStream); } known.put(name, stream); } return stream;
public static int	parseLevel(java.lang.String s) Convert a string name of a logging level to its internal integer representation. param s name of logging level (e.g., 'SILENT', 'BRIEF', 'VERBOSE') return corresponding integer log level since JDK1.1 deprecated no replacement 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;
public static synchronized void	setDefaultStream(java.io.PrintStream newDefault) Set the default stream for new logs. param newDefault new default log stream see #getDefaultStream since JDK1.1 deprecated no replacement defaultStream = newDefault;
public synchronized void	setOutputStream(java.io.OutputStream out) Set the stream to which output from this log is sent. param out new output stream for this log see #getOutputStream since JDK1.1 deprecated no replacement logOut = out; // Maintain an OutputStreamWriter with default CharToByteConvertor // (just like new PrintStream) for writing log message prefixes. logWriter = new OutputStreamWriter(logOut);
public java.lang.String	toString() Return log name as string representation. return log name since JDK1.1 deprecated no replacement return name;
public void	write(int 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. since JDK1.1 deprecated no replacement 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);
public void	write(byte[] b, int off, int len) Write a subarray of bytes. Pass each through write byte method. since JDK1.1 deprecated no replacement if (len < 0) throw new ArrayIndexOutOfBoundsException(len); for (int i = 0; i < len; ++ i) write(b[off + i]);