OioByteStreamChannel Class — netty Architecture

Source Code

transport/src/main/java/io/netty/channel/oio/OioByteStreamChannel.java lines 38–172

@Deprecated
public abstract class OioByteStreamChannel extends AbstractOioByteChannel {

    private static final InputStream CLOSED_IN = new InputStream() {
        @Override
        public int read() {
            return -1;
        }
    };

    private static final OutputStream CLOSED_OUT = new OutputStream() {
        @Override
        public void write(int b) throws IOException {
            throw new ClosedChannelException();
        }
    };

    private InputStream is;
    private OutputStream os;
    private WritableByteChannel outChannel;

    /**
     * Create a new instance
     *
     * @param parent    the parent {@link Channel} which was used to create this instance. This can be null if the
     *                  {@link} has no parent as it was created by your self.
     */
    protected OioByteStreamChannel(Channel parent) {
        super(parent);
    }

    /**
     * Activate this instance. After this call {@link #isActive()} will return {@code true}.
     */
    protected final void activate(InputStream is, OutputStream os) {
        if (this.is != null) {
            throw new IllegalStateException("input was set already");
        }
        if (this.os != null) {
            throw new IllegalStateException("output was set already");
        }
        this.is = ObjectUtil.checkNotNull(is, "is");
        this.os = ObjectUtil.checkNotNull(os, "os");
        if (readWhenInactive) {
            eventLoop().execute(readTask);
            readWhenInactive = false;
        }
    }

    @Override
    public boolean isActive() {
        InputStream is = this.is;
        if (is == null || is == CLOSED_IN) {
            return false;
        }

        OutputStream os = this.os;
        return !(os == null || os == CLOSED_OUT);
    }

    @Override
    protected int available() {
        try {
            return is.available();
        } catch (IOException ignored) {
            return 0;
        }
    }

    @Override
    protected int doReadBytes(ByteBuf buf) throws Exception {
        final RecvByteBufAllocator.Handle allocHandle = unsafe().recvBufAllocHandle();
        allocHandle.attemptedBytesRead(Math.max(1, Math.min(available(), buf.maxWritableBytes())));
        return buf.writeBytes(is, allocHandle.attemptedBytesRead());
    }

    @Override
    protected void doWriteBytes(ByteBuf buf) throws Exception {
        OutputStream os = this.os;
        if (os == null) {
            throw new NotYetConnectedException();