PooledSlicedByteBuf Class — netty Architecture

Source Code

buffer/src/main/java/io/netty/buffer/PooledSlicedByteBuf.java lines 33–440

final class PooledSlicedByteBuf extends AbstractPooledDerivedByteBuf {

    private static final Recycler<PooledSlicedByteBuf> RECYCLER =
            new Recycler<PooledSlicedByteBuf>() {
                @Override
                protected PooledSlicedByteBuf newObject(Handle<PooledSlicedByteBuf> handle) {
                    return new PooledSlicedByteBuf(handle);
                }
            };

    static PooledSlicedByteBuf newInstance(AbstractByteBuf unwrapped, ByteBuf wrapped,
                                           int index, int length) {
        checkSliceOutOfBounds(index, length, unwrapped);
        return newInstance0(unwrapped, wrapped, index, length);
    }

    private static PooledSlicedByteBuf newInstance0(AbstractByteBuf unwrapped, ByteBuf wrapped,
                                                    int adjustment, int length) {
        final PooledSlicedByteBuf slice = RECYCLER.get();
        slice.init(unwrapped, wrapped, 0, length, length);
        slice.discardMarks();
        slice.adjustment = adjustment;

        return slice;
    }

    int adjustment;

    private PooledSlicedByteBuf(Handle<PooledSlicedByteBuf> handle) {
        super(handle);
    }

    @Override
    public int capacity() {
        return maxCapacity();
    }

    @Override
    public ByteBuf capacity(int newCapacity) {
        throw new UnsupportedOperationException("sliced buffer");
    }

    @Override
    public int arrayOffset() {
        return idx(unwrap().arrayOffset());
    }

    @Override
    public long memoryAddress() {
        return unwrap().memoryAddress() + adjustment;
    }

    @Override
    public ByteBuffer nioBuffer(int index, int length) {
        checkIndex0(index, length);
        return unwrap().nioBuffer(idx(index), length);
    }

    @Override
    public ByteBuffer[] nioBuffers(int index, int length) {
        checkIndex0(index, length);
        return unwrap().nioBuffers(idx(index), length);
    }

    @Override
    public ByteBuf copy(int index, int length) {
        checkIndex0(index, length);
        return unwrap().copy(idx(index), length);
    }

    @Override
    public ByteBuf slice(int index, int length) {
        checkIndex0(index, length);
        return super.slice(idx(index), length);
    }

    @Override
    public ByteBuf retainedSlice(int index, int length) {
        checkIndex0(index, length);
        return PooledSlicedByteBuf.newInstance0(unwrap(), this, idx(index), length);
    }