ByteBufOutputStream Class — netty Architecture

Source Code

buffer/src/main/java/io/netty/buffer/ByteBufOutputStream.java lines 38–188

public class ByteBufOutputStream extends OutputStream implements DataOutput {

    private final ByteBuf buffer;
    private final int startIndex;
    private DataOutputStream utf8out; // lazily-instantiated
    private boolean closed;
    private final boolean releaseOnClose;

    /**
     * Creates a new stream which writes data to the specified {@code buffer}.
     */
    public ByteBufOutputStream(ByteBuf buffer) {
        this(buffer, false);
    }

    /**
     * Creates a new stream which writes data to the specified {@code buffer}.
     *
     * @param buffer Writes data to the buffer for this {@link OutputStream}.
     * @param releaseOnClose {@code true} means that when {@link #close()} is called then {@link ByteBuf#release()} will
     *                       be called on {@code buffer}.
     */
    public ByteBufOutputStream(ByteBuf buffer, boolean releaseOnClose) {
        this.releaseOnClose = releaseOnClose;
        this.buffer = ObjectUtil.checkNotNull(buffer, "buffer");
        startIndex = buffer.writerIndex();
    }

    /**
     * Returns the number of written bytes by this stream so far.
     */
    public int writtenBytes() {
        return buffer.writerIndex() - startIndex;
    }

    @Override
    public void write(byte[] b, int off, int len) throws IOException {
        buffer.writeBytes(b, off, len);
    }

    @Override
    public void write(byte[] b) throws IOException {
        buffer.writeBytes(b);
    }

    @Override
    public void write(int b) throws IOException {
        buffer.writeByte(b);
    }

    @Override
    public void writeBoolean(boolean v) throws IOException {
        buffer.writeBoolean(v);
    }

    @Override
    public void writeByte(int v) throws IOException {
        buffer.writeByte(v);
    }

    @Override
    public void writeBytes(String s) throws IOException {
        // We don't use `ByteBuf.writeCharSequence` here, because `writeBytes` is specified to only write the
        // lower-order by of multibyte characters (exactly one byte per character in the string), while
        // `writeCharSequence` will instead write a '?' replacement character.
        int length = s.length();
        buffer.ensureWritable(length);
        int offset = buffer.writerIndex();
        for (int i = 0; i < length; i++) {
            buffer.setByte(offset + i, (byte) s.charAt(i));
        }
        buffer.writerIndex(offset + length);
    }

    @Override
    public void writeChar(int v) throws IOException {
        buffer.writeChar(v);
    }

    @Override
    public void writeChars(String s) throws IOException {