FileDocCategorySizeDatePackage
LoggingOutputStream.javaAPI DocApache log4j 1.2.155941Sat Aug 25 00:09:34 BST 2007None

LoggingOutputStream

public class LoggingOutputStream extends OutputStream
An OutputStream that flushes out to a Category.

Note that no data is written out to the Category until the stream is flushed or closed.

Example:

// make sure everything sent to System.err is logged
System.setErr(new PrintStream(new LoggingOutputStream(Category.getRoot(), Priority.WARN), true));

// make sure everything sent to System.out is also logged
System.setOut(new PrintStream(new LoggingOutputStream(Category.getRoot(), Priority.INFO), true));
author
Jim Moore
see
Category

Fields Summary
protected static final String
LINE_SEPERATOR
protected boolean
hasBeenClosed
Used to maintain the contract of {@link #close()}.
protected byte[]
buf
The internal buffer where data is stored.
protected int
count
The number of valid bytes in the buffer. This value is always in the range 0 through buf.length; elements buf[0] through buf[count-1] contain valid byte data.
private int
bufLength
Remembers the size of the buffer for speed.
public static final int
DEFAULT_BUFFER_LENGTH
The default number of bytes in the buffer. =2048
protected Category
category
The category to write to.
protected Priority
priority
The priority to use when writing to the Category.
Constructors Summary
private LoggingOutputStream()



    
    // illegal
public LoggingOutputStream(Category cat, Priority priority)
Creates the LoggingOutputStream to flush to the given Category.

param
cat the Category to write to
param
priority the Priority to use when writing to the Category
exception
IllegalArgumentException if cat == null or priority == null

    if (cat == null) {
      throw new IllegalArgumentException("cat == null");
    }
    if (priority == null) {
      throw new IllegalArgumentException("priority == null");
    }

    this.priority = priority;
    category = cat;
    bufLength = DEFAULT_BUFFER_LENGTH;
    buf = new byte[DEFAULT_BUFFER_LENGTH];
    count = 0;
Methods Summary
public voidclose()
Closes this output stream and releases any system resources associated with this stream. The general contract of close is that it closes the output stream. A closed stream cannot perform output operations and cannot be reopened.

    flush();
    hasBeenClosed = true;
public voidflush()
Flushes this output stream and forces any buffered output bytes to be written out. The general contract of flush is that calling it is an indication that, if any bytes previously written have been buffered by the implementation of the output stream, such bytes should immediately be written to their intended destination.

    if (count == 0) {
      return;
    }

    // don't print out blank lines; flushing from PrintStream puts out these
    if (count == LINE_SEPERATOR.length()) {
      if ( ((char)buf[0]) == LINE_SEPERATOR.charAt(0)  &&
           ( ( count == 1 ) ||  // <- Unix & Mac, -> Windows
             ( (count == 2) && ((char)buf[1]) == LINE_SEPERATOR.charAt(1) ) ) ) {
        reset();
        return;
      }
    }

    final byte[] theBytes = new byte[count];

    System.arraycopy(buf, 0, theBytes, 0, count);

    category.log(priority, new String(theBytes));

    reset();
private voidreset()

    // not resetting the buffer -- assuming that if it grew that it
    //   will likely grow similarly again
    count = 0;
public voidwrite(int b)
Writes the specified byte to this output stream. The general contract for write is that one byte is written to the output stream. The byte to be written is the eight low-order bits of the argument b. The 24 high-order bits of b are ignored.

param
b the byte to write
exception
IOException if an I/O error occurs. In particular, an IOException may be thrown if the output stream has been closed.

    if (hasBeenClosed) {
      throw new IOException("The stream has been closed.");
    }

    // don't log nulls
    if (b == 0) {
      return;
    }

    // would this be writing past the buffer?
    if (count == bufLength) {
      // grow the buffer
      final int newBufLength = bufLength+DEFAULT_BUFFER_LENGTH;
      final byte[] newBuf = new byte[newBufLength];

      System.arraycopy(buf, 0, newBuf, 0, bufLength);

      buf = newBuf;
      bufLength = newBufLength;
    }

    buf[count] = (byte)b;
    count++;