CoyoteOutputStream (Apache Tomcat 11.0.22 API Documentation)
Description: declaration: package: org.apache.catalina.connector, class: CoyoteOutputStream

# Class CoyoteOutputStream

java.lang.Object
java.io.OutputStream
jakarta.servlet.ServletOutputStream
org.apache.catalina.connector.CoyoteOutputStream

All Implemented Interfaces:
  `Closeable, Flushable, AutoCloseable`

public class CoyoteOutputStream extends ServletOutputStream
Coyote implementation of the servlet output stream.

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected OutputBuffer`
  `ob`
  `protected static final StringManager`
  `sm`

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `CoyoteOutputStream(OutputBuffer ob)`

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected Object`
  `clone()`
  Prevent cloning the facade.
  `void`
  `close()`
  `void`
  `flush()`
  Will send the buffer to the client.
  `boolean`
  `isReady()`
  Returns `true` if it is allowable to call any method that may write data (e.g.
  `void`
  `setWriteListener(WriteListener listener)`
  Sets the `WriteListener` for this `ServletOutputStream` and thereby switches to non-blocking IO.
  `void`
  `write(byte[] b)`
  `void`
  `write(byte[] b, int off, int len)`
  `void`
  `write(int i)`
  `void`
  `write(ByteBuffer from)`
  Writes from the given buffer to the output stream.

  ### Methods inherited from class ServletOutputStream

  `print, print, print, print, print, print, print, println, println, println, println, println, println, println, println`

  ### Methods inherited from class OutputStream

  `nullOutputStream`

  ### Methods inherited from class Object

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

- ## Field Details

  - ### sm

    protected static final StringManager sm

  - ### ob

    protected OutputBuffer ob

- ## Constructor Details

  - ### CoyoteOutputStream

    protected CoyoteOutputStream(OutputBuffer ob)

- ## Method Details

  - ### clone

    protected Object clone() throws CloneNotSupportedException
    Prevent cloning the facade.
    Overrides:
      `clone` in class `Object`
    Throws:
      `CloneNotSupportedException`

  - ### write

    public void write(int i) throws IOException
    Specified by:
      `write` in class `OutputStream`
    Throws:
      `IOException`

  - ### write

    public void write(byte[] b) throws IOException
    Overrides:
      `write` in class `OutputStream`
    Throws:
      `IOException`

  - ### write

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

  - ### write

    public void write(ByteBuffer from) throws IOException
    Description copied from class: `jakarta.servlet.ServletOutputStream`
    Writes from the given buffer to the output stream.

    If the output steam is in non-blocking mode, before each invocation of this method `ServletOutputStream.isReady()` must be called and must return `true` or the `WriteListener.onWritePossible()` call back must indicate that data may be written else an `IllegalStateException` must be thrown.

    Otherwise, if this method is called when `buffer` has no data remaining, the method returns immediately and `buffer` is unchanged.

    If the output stream is in non-blocking mode, neither the position, limit nor content of the buffer passed to this method may be modified until a subsequent call to `ServletOutputStream.isReady()` returns true or the `WriteListener.onWritePossible()` call back indicates data may be written again. At this point the buffer's limit will be unchanged from the value when passed to this method and the position will be the same as the limit.

    If the output stream is in blocking mode and `buffer` has space remaining, this method blocks until all the remaining data in the buffer has been written. When the method returns, and if data has been written, the buffer's limit will be unchanged from the value when passed to this method and the position will be the same as the limit.

    Subclasses are strongly encouraged to override this method and provide a more efficient implementation.

    Overrides:
      `write` in class `ServletOutputStream`
    Parameters:
      `from` - The buffer from which the data is written.
    Throws:
      `IOException` - If the output stream has been closed or if some other I/O error occurs.

  - ### flush

    public void flush() throws IOException
    Will send the buffer to the client.
    Specified by:
      `flush` in interface `Flushable`
    Overrides:
      `flush` in class `OutputStream`
    Throws:
      `IOException`

  - ### close

    public void close() throws IOException
    Description copied from class: `jakarta.servlet.ServletOutputStream`

    If this method is called when the output stream is in non-blocking mode, it will immediately return with the stream effectively closed, even if the stream contains buffered data that is yet to be written to client. The container will write this data out in the background. If this process fails the `WriteListener.onError(Throwable)` method will be invoked as normal.

    Specified by:
      `close` in interface `AutoCloseable`
    Specified by:
      `close` in interface `Closeable`
    Overrides:
      `close` in class `ServletOutputStream`
    Throws:
      `IOException`

  - ### isReady

    public boolean isReady()
    Description copied from class: `jakarta.servlet.ServletOutputStream`
    Returns `true` if it is allowable to call any method that may write data (e.g. `write()`, `print()` or `flush`). In blocking mode, this method will always return `true`, but a subsequent call to a method that writes data may block. In non-blocking mode this method may return `false`, in which case it is illegal to call a method that writes data and an `IllegalStateException` MUST be thrown. When `WriteListener.onWritePossible()` is called, a call to this method that returned `true` is implicit.

    If this method returns `false` and a `WriteListener` has been set via `ServletOutputStream.setWriteListener(WriteListener)`, then container will subsequently invoke `WriteListener.onWritePossible()` once a write operation becomes possible without blocking. Other than the initial call, `WriteListener.onWritePossible()` will only be called if and only if this method is called and returns false.

    Specified by:
      `isReady` in class `ServletOutputStream`
    Returns:
      `true` if data can be written without blocking, otherwise returns `false`.

  - ### setWriteListener

    public void setWriteListener(WriteListener listener)
    Description copied from class: `jakarta.servlet.ServletOutputStream`
    Sets the `WriteListener` for this `ServletOutputStream` and thereby switches to non-blocking IO. It is only valid to switch to non-blocking IO within async processing or HTTP upgrade processing.
    Specified by:
      `setWriteListener` in class `ServletOutputStream`
    Parameters:
      `listener` - The non-blocking IO write listener