public OutputBuffer() 
{
    // ----------------------------------------------------------- Constructors
        this(DEFAULT_BUFFER_SIZE);
}

Default constructor. Allocate the buffer with the default buffer size.

 public OutputBuffer(int size) 
{
        bb = new ByteChunk(size);
        bb.setLimit(size);
        bb.setByteOutputChannel(this);
        cb = new CharChunk(size);
        cb.setCharOutputChannel(this);
        cb.setLimit(size);
}

Alternate constructor which allows specifying the initial buffer size.

Parameters:

size - Buffer size to use

 public  void close() throws IOException 
{
        if (closed)
            return;
        if (suspended)
            return;
        if ((!coyoteResponse.isCommitted()) 
            && (coyoteResponse.getContentLengthLong() == -1)) {
            // Flushing the char buffer
            if (state == CHAR_STATE) {
                cb.flushBuffer();
                state = BYTE_STATE;
            }
            // If this didn't cause a commit of the response, the final content
            // length can be calculated
            if (!coyoteResponse.isCommitted()) {
                coyoteResponse.setContentLength(bb.getLength());
            }
        }
        doFlush(false);
        closed = true;
        coyoteResponse.finish();
}

Close the output buffer. This tries to calculate the response size if the response has not been committed yet.

 protected  void doFlush(boolean realFlush) throws IOException 
{
        if (suspended)
            return;
        doFlush = true;
        if (state == CHAR_STATE) {
            cb.flushBuffer();
            bb.flushBuffer();
            state = BYTE_STATE;
        } else if (state == BYTE_STATE) {
            bb.flushBuffer();
        } else if (state == INITIAL_STATE)
            realWriteBytes(null, 0, 0);       // nothing written yet
        doFlush = false;
        if (realFlush) {
            coyoteResponse.action(ActionCode.ACTION_CLIENT_FLUSH, 
                                  coyoteResponse);
            // If some exception occurred earlier, or if some IOE occurred
            // here, notify the servlet with an IOE
            if (coyoteResponse.isExceptionPresent()) {
                throw new ClientAbortException
                    (coyoteResponse.getErrorException());
            }
        }
}

Flush bytes or chars contained in the buffer.

 public  void flush() throws IOException 
{
        doFlush(true);
}

Flush bytes or chars contained in the buffer.

 public  void flushBytes() throws IOException 
{
        if (debug  > 0)
            log("flushBytes() " + bb.getLength());
        bb.flushBuffer();
}

Real write - this buffer will be sent to the client

 public  void flushChars() throws IOException 
{
        if (debug  > 0)
            log("flushChars() " + cb.getLength());
        cb.flushBuffer();
        state = BYTE_STATE;
}

 public boolean flushCharsNeeded() 
{
        return state == CHAR_STATE;
}

 public int getBufferSize() 
{
	return bb.getLimit();
}

 public int getBytesWritten() 
{
        return bytesWritten;
}

 public int getCharsWritten() 
{
        return charsWritten;
}

 public int getContentWritten() 
{
        return bytesWritten + charsWritten;
}

 public Response getResponse() 
{
        return this.coyoteResponse;
}

Get associated Coyote response.

 public boolean isNew() 
{
        return (bytesWritten == 0) && (charsWritten == 0);
}

True if this buffer hasn't been used ( since recycle() ) - i.e. no chars or bytes have been added to the buffer.

 public boolean isSuspended() 
{
        return this.suspended;
}

Is the response output suspended ?

 protected  void log(String s) 
{
        if (log.isDebugEnabled()) 
            log.debug("OutputBuffer: " + s);
}

 public  void realWriteBytes(byte[] buf,
    int off,
    int cnt) throws IOException 
{
        if (debug  > 2)
            log("realWrite(b, " + off + ", " + cnt + ") " + coyoteResponse);
        if (closed)
            return;
        if (coyoteResponse == null)
            return;
        // If we really have something to write
        if (cnt  > 0) {
            // real write to the adapter
            outputChunk.setBytes(buf, off, cnt);
            try {
                coyoteResponse.doWrite(outputChunk);
            } catch (IOException e) {
                // An IOException on a write is almost always due to
                // the remote client aborting the request.  Wrap this
                // so that it can be handled better by the error dispatcher.
                throw new ClientAbortException(e);
            }
        }
}

Sends the buffer data to the client output, checking the state of Response and calling the right interceptors.

 public  void realWriteChars(char[] c,
    int off,
    int len) throws IOException 
{
        if (debug  > 0)
            log("realWrite(c,o,l) " + cb.getOffset() + " " + len);
        if (!gotEnc)
            setConverter();
        if (debug  > 0)
            log("encoder:  " + conv + " " + gotEnc);
        conv.convert(c, off, len);
        conv.flushBuffer();	// ???
}

 public  void recycle() 
{
	if (debug  > 0)
            log("recycle()");
	state = INITIAL_STATE;
	bytesWritten = 0;
	charsWritten = 0;
        cb.recycle();
        bb.recycle(); 
        closed = false;
        suspended = false;
        if (conv!= null) {
            conv.recycle();
        }
        gotEnc = false;
        enc = null;
}

Recycle the output buffer.

 public  void reset() 
{
        //count=0;
        bb.recycle();
        bytesWritten = 0;
        cb.recycle();
        charsWritten = 0;
        gotEnc = false;
        enc = null;
}

 public  void setBufferSize(int size) 
{
        if (size  > bb.getLimit()) {// ??????
	    bb.setLimit(size);
	}
}

 protected  void setConverter() 
{
        if (coyoteResponse != null)
            enc = coyoteResponse.getCharacterEncoding();
        if (debug  > 0)
            log("Got encoding: " + enc);
        gotEnc = true;
        if (enc == null)
            enc = DEFAULT_ENCODING;
        conv = (C2BConverter) encoders.get(enc);
        if (conv == null) {
            try {
                conv = new C2BConverter(bb, enc);
                encoders.put(enc, conv);
            } catch (IOException e) {
                conv = (C2BConverter) encoders.get(DEFAULT_ENCODING);
                if (conv == null) {
                    try {
                        conv = new C2BConverter(bb, DEFAULT_ENCODING);
                        encoders.put(DEFAULT_ENCODING, conv);
                    } catch (IOException ex) {
                        // Ignore
                    }
                }
            }
        }
}

 public  void setEncoding(String s) 
{
        enc = s;
}

 public  void setResponse(Response coyoteResponse) 
{
	this.coyoteResponse = coyoteResponse;
}

Associated Coyote response.

 public  void setSuspended(boolean suspended) 
{
        this.suspended = suspended;
}

Set the suspended flag.

 public  void write(int c) throws IOException 
{
        if (suspended)
            return;
        state = CHAR_STATE;
        if (debug  > 0)
            log("writeChar(b)");
        cb.append((char) c);
        charsWritten++;
}

 public  void write(char[] c) throws IOException 
{
        if (suspended)
            return;
        write(c, 0, c.length);
}

 public  void write(StringBuffer sb) throws IOException 
{
        if (suspended)
            return;
        state = CHAR_STATE;
        if (debug  > 1)
            log("write(s,off,len)");
        int len = sb.length();
        charsWritten += len;
        cb.append(sb);
}

 public  void write(String s) throws IOException 
{
        if (suspended)
            return;
        state = CHAR_STATE;
        if (s==null)
            s="null";
        write(s, 0, s.length());
}

 public  void write(byte[] b,
    int off,
    int len) throws IOException 
{
        if (suspended)
            return;
        if (state == CHAR_STATE)
            cb.flushBuffer();
        state = BYTE_STATE;
        writeBytes(b, off, len);
}

 public  void write(char[] c,
    int off,
    int len) throws IOException 
{
        if (suspended)
            return;
        state = CHAR_STATE;
        if (debug  > 0)
            log("write(c,off,len)" + cb.getLength() + " " + cb.getLimit());
        cb.append(c, off, len);
        charsWritten += len;
}

 public  void write(String s,
    int off,
    int len) throws IOException 
{
        if (suspended)
            return;
        state=CHAR_STATE;
        if (debug  > 1)
            log("write(s,off,len)");
        charsWritten += len;
        if (s==null)
            s="null";
        cb.append( s, off, len );
}

Append a string to the buffer

 public  void writeByte(int b) throws IOException 
{
        if (suspended)
            return;
        if (state == CHAR_STATE)
            cb.flushBuffer();
        state = BYTE_STATE;
        if (debug  > 0)
            log("write(b)");
        bb.append( (byte)b );
        bytesWritten++;
}