Start line:  
End line:  

Snippet Preview

Snippet HTML Code

Stack Overflow Questions
  /*
   * Copyright 2010-2013 Ning, Inc.
   *
   * Ning licenses this file to you under the Apache License, version 2.0
   * (the "License"); you may not use this file except in compliance with the
   * License.  You may obtain a copy of the License at:
   *
   *    http://www.apache.org/licenses/LICENSE-2.0
   *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
  * WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.  See the
  * License for the specific language governing permissions and limitations
  * under the License.
  */
 
 package com.ning.billing.commons.embeddeddb.mysql;
 
 
Adapted from http://www.mail-archive.com/user@slf4j.org/msg00674.html for slf4j.

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(Logger.getRootCategory(),
 Level.WARN), true));
 

// make sure everything sent to System.out is also logged System.setOut(new PrintStream(new LoggingOutputStream(Logger.getRootCategory(), Level.INFO), true));

Author(s):
Jim Moore
See also:
{{http://www.mail-archive.com/user@slf4j.org/msg00674.html}}
 
 
 public class LoggingOutputStream extends OutputStream {

    
Used to maintain the contract of [EMAIL PROTECTED] #close()}.
 
     private boolean hasBeenClosed = false;

    
The internal buffer where data is stored.
 
     private byte[] buf;

    
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 count;

    
Remembers the size of the buffer for speed.
 
     private int bufLength;

    
The default number of bytes in the buffer. =2048
 
     public static final int DEFAULT_BUFFER_LENGTH = 2048;

    
The category to write to.
 
     private final Logger logger;

    
Creates the LoggingOutputStream to flush to the given Category.

Parameters:
log the Logger to write to
Throws:
java.lang.IllegalArgumentException if log == null
 
     public LoggingOutputStream(final Logger logthrows IllegalArgumentException {
         if (log == null) {
             throw new IllegalArgumentException("log == null");
         }
 
          = log;
          = ;
          = new byte[];
          = 0;
     }

    
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.
    public void close() {
        flush();
         = true;
    }

    
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.

Parameters:
b the byte to write
Throws:
java.io.IOException if an I/O error occurs. In particular, an IOException may be thrown if the output stream has been closed.
    public void write(final int bthrows IOException {
        if () {
            throw new IOException("The stream has been closed.");
        }
        if (((charb) == '\r' || ((charb) == '\n') {
            return;
        }
        // would this be writing past the buffer?
        if ( == ) {
            // grow the buffer
            final int newBufLength =  + ;
            final byte[] newBuf = new byte[newBufLength];
            System.arraycopy(, 0, newBuf, 0, );
             = newBuf;
             = newBufLength;
        }
        [] = (byteb;
        ++;
    }

    
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.
    public void flush() {
        if ( == 0) {
            return;
        }
        // don't print out blank lines; flushing from PrintStream puts
        // For linux system
        if ( == 1 && ((char[0]) == '\n') {
            reset();
            return;
        }
        // For mac system
        if ( == 1 && ((char[0]) == '\r') {
            reset();
            return;
        }
        // On windows system
        if ( == 2 && (char[0] == '\r' && (char[1] == '\n') {
            reset();
            return;
        }
        final byte[] theBytes = new byte[];
        System.arraycopy(, 0, theBytes, 0, );
        .debug(new String(theBytes));
        reset();
    }
    private void reset() {
        // not resetting the buffer -- assuming that if it grew then it will likely grow similarly again
         = 0;
    }
New to GrepCode? Check out our FAQ X