# Class OutputBuffer

java.lang.Object
java.io.Writer
org.apache.catalina.connector.OutputBuffer

All Implemented Interfaces:
  `Closeable, Flushable, Appendable, AutoCloseable`

public class OutputBuffer extends Writer
The buffer used by Tomcat response. This is a derivative of the Tomcat 3.3 OutputBuffer, with the removal of some of the state handling (which in Coyote is mostly the Processor's responsibility).

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected C2BConverter`
  `conv`
  Current char to byte converter.
  `static final int`
  `DEFAULT_BUFFER_SIZE`

  ### Fields inherited from class Writer

  `lock`

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `OutputBuffer(int size, Response coyoteResponse)`
  Create the buffer with the specified initial size.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `append(byte[] src, int off, int len)`
  Add data to the buffer.
  `void`
  `append(char[] src, int off, int len)`
  Add data to the buffer.
  `void`
  `append(ByteBuffer from)`
  `void`
  `checkConverter()`
  `void`
  `checkRegisterForWrite()`
  `void`
  `close()`
  Close the output buffer.
  `protected void`
  `doFlush(boolean realFlush)`
  Flush bytes or chars contained in the buffer.
  `void`
  `flush()`
  Flush bytes or chars contained in the buffer.
  `int`
  `getBufferSize()`
  `long`
  `getContentWritten()`
  `boolean`
  `isBlocking()`
  `boolean`
  `isClosed()`
  Is the response output closed ?
  `boolean`
  `isNew()`
  Has this buffer been used at all?
  `boolean`
  `isReady()`
  `boolean`
  `isSuspended()`
  Is the response output suspended ?
  `void`
  `realWriteBytes(ByteBuffer buf)`
  Sends the buffer data to the client output, checking the state of Response and calling the right interceptors.
  `void`
  `realWriteChars(CharBuffer from)`
  Convert the chars to bytes, then send the data to the client.
  `void`
  `recycle()`
  Recycle the output buffer.
  `void`
  `reset()`
  `void`
  `reset(boolean resetWriterStreamFlags)`
  `void`
  `setBufferSize(int size)`
  `void`
  `setErrorException(Exception e)`
  `void`
  `setSuspended(boolean suspended)`
  Set the suspended flag.
  `void`
  `setWriteListener(WriteListener listener)`
  `void`
  `write(byte[] b, int off, int len)`
  `void`
  `write(char[] c)`
  `void`
  `write(char[] c, int off, int len)`
  `void`
  `write(int c)`
  `void`
  `write(String s)`
  `void`
  `write(String s, int off, int len)`
  Append a string to the buffer
  `void`
  `write(ByteBuffer from)`
  `void`
  `writeByte(int b)`

  ### Methods inherited from class Writer

  `append, append, append, nullWriter`

  ### Methods inherited from class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- ## Field Details

  - ### DEFAULT_BUFFER_SIZE

    public static final int DEFAULT_BUFFER_SIZE
    See Also:
      - Constant Field Values

  - ### conv

    protected C2BConverter conv
    Current char to byte converter.

- ## Constructor Details

  - ### OutputBuffer

    public OutputBuffer(int size, Response coyoteResponse)
    Create the buffer with the specified initial size.
    Parameters:
      `size` - Buffer size to use
      `coyoteResponse` - The associated Coyote response

- ## Method Details

  - ### isSuspended

    public boolean isSuspended()
    Is the response output suspended ?
    Returns:
      suspended flag value

  - ### setSuspended

    public void setSuspended(boolean suspended)
    Set the suspended flag.
    Parameters:
      `suspended` - New suspended flag value

  - ### isClosed

    public boolean isClosed()
    Is the response output closed ?
    Returns:
      closed flag value

  - ### recycle

    public void recycle()
    Recycle the output buffer.

  - ### close

    public void close() throws IOException
    Close the output buffer. This tries to calculate the response size if the response has not been committed yet.
    Specified by:
      `close` in interface `AutoCloseable`
    Specified by:
      `close` in interface `Closeable`
    Specified by:
      `close` in class `Writer`
    Throws:
      `IOException` - An underlying IOException occurred

  - ### flush

    public void flush() throws IOException
    Flush bytes or chars contained in the buffer.
    Specified by:
      `flush` in interface `Flushable`
    Specified by:
      `flush` in class `Writer`
    Throws:
      `IOException` - An underlying IOException occurred

  - ### doFlush

    protected void doFlush(boolean realFlush) throws IOException
    Flush bytes or chars contained in the buffer.
    Parameters:
      `realFlush` - `true` if this should also cause a real network flush
    Throws:
      `IOException` - An underlying IOException occurred

  - ### realWriteBytes

    public void realWriteBytes(ByteBuffer buf) throws IOException
    Sends the buffer data to the client output, checking the state of Response and calling the right interceptors.
    Parameters:
      `buf` - the ByteBuffer to be written to the response
    Throws:
      `IOException` - An underlying IOException occurred

  - ### write

    public void write(byte[] b, int off, int len) throws IOException
    Throws:
      `IOException`

  - ### write

    public void write(ByteBuffer from) throws IOException
    Throws:
      `IOException`

  - ### writeByte

    public void writeByte(int b) throws IOException
    Throws:
      `IOException`

  - ### realWriteChars

    public void realWriteChars(CharBuffer from) throws IOException
    Convert the chars to bytes, then send the data to the client.
    Parameters:
      `from` - Char buffer to be written to the response
    Throws:
      `IOException` - An underlying IOException occurred

  - ### write

    public void write(int c) throws IOException
    Overrides:
      `write` in class `Writer`
    Throws:
      `IOException`

  - ### write

    public void write(char[] c) throws IOException
    Overrides:
      `write` in class `Writer`
    Throws:
      `IOException`

  - ### write

    public void write(char[] c, int off, int len) throws IOException
    Specified by:
      `write` in class `Writer`
    Throws:
      `IOException`

  - ### write

    public void write(String s, int off, int len) throws IOException
    Append a string to the buffer
    Overrides:
      `write` in class `Writer`
    Throws:
      `IOException`

  - ### write

    public void write(String s) throws IOException
    Overrides:
      `write` in class `Writer`
    Throws:
      `IOException`

  - ### checkConverter

    public void checkConverter() throws IOException
    Throws:
      `IOException`

  - ### getContentWritten

    public long getContentWritten()

  - ### isNew

    public boolean isNew()
    Has this buffer been used at all?
    Returns:
      true if no chars or bytes have been added to the buffer since the last call to `recycle()`

  - ### setBufferSize

    public void setBufferSize(int size)

  - ### reset

    public void reset()

  - ### reset

    public void reset(boolean resetWriterStreamFlags)

  - ### getBufferSize

    public int getBufferSize()

  - ### isReady

    public boolean isReady()

  - ### setWriteListener

    public void setWriteListener(WriteListener listener)

  - ### isBlocking

    public boolean isBlocking()

  - ### checkRegisterForWrite

    public void checkRegisterForWrite()

  - ### append

    public void append(byte[] src, int off, int len) throws IOException
    Add data to the buffer.
    Parameters:
      `src` - Bytes array
      `off` - Offset
      `len` - Length
    Throws:
      `IOException` - Writing overflow data to the output channel failed

  - ### append

    public void append(char[] src, int off, int len) throws IOException
    Add data to the buffer.
    Parameters:
      `src` - Char array
      `off` - Offset
      `len` - Length
    Throws:
      `IOException` - Writing overflow data to the output channel failed

  - ### append

    public void append(ByteBuffer from) throws IOException
    Throws:
      `IOException`

  - ### setErrorException

    public void setErrorException(Exception e)