Rename skipReadable(...) and skipWritable(...) to be more consistent …

…with the rest of the API (#12458)

Motivation:

We use readableBytes(...) and writableBytes(...) etc so we should also name the methods skipReadableBytes(...) and skipWritableBytes(...) to make the API more consistent in terms of naming

Modifications:

Rename methods

Result:

More consistent naming of methods in the API

buffer/src/main/java/io/netty5/buffer/BufferInputStream.java

@@ -203,7 +203,7 @@ public String readLine() throws IOException {
 
                 case '\r':
                     if (available > 0 && (char) buffer.getUnsignedByte(buffer.readerOffset()) == '\n') {
-                        buffer.skipReadable(1);
+                        buffer.skipReadableBytes(1);
                     }
                     break loop;
 
@@ -248,7 +248,7 @@ public int readUnsignedShort() throws IOException {
     @Override
     public int skipBytes(int n) throws IOException {
         int nBytes = Math.min(available(), n);
-        buffer.skipReadable(nBytes);
+        buffer.skipReadableBytes(nBytes);
         return nBytes;
     }
 

buffer/src/main/java/io/netty5/buffer/api/Buffer.java

@@ -141,7 +141,7 @@ public interface Buffer extends Resource<Buffer>, BufferAccessor {
      * @throws IllegalArgumentException if the given delta is negative.
      * @throws BufferClosedException if this buffer is closed.
      */
-    default Buffer skipReadable(int delta) {
+    default Buffer skipReadableBytes(int delta) {
         checkPositiveOrZero(delta, "delta");
         readerOffset(readerOffset() + delta);
         return this;
@@ -175,7 +175,7 @@ default Buffer skipReadable(int delta) {
      * @throws BufferClosedException if this buffer is closed.
      * @throws BufferReadOnlyException if this buffer is {@linkplain #readOnly() read-only}.
      */
-    default Buffer skipWritable(int delta) {
+    default Buffer skipWritableBytes(int delta) {
         checkPositiveOrZero(delta, "delta");
         writerOffset(writerOffset() + delta);
         return this;
@@ -435,8 +435,8 @@ default Buffer writeBytes(Buffer source) {
         }
         int woff = writerOffset();
         source.copyInto(source.readerOffset(), this, woff, size);
-        source.skipReadable(size);
-        skipWritable(size);
+        source.skipReadableBytes(size);
+        skipWritableBytes(size);
         return this;
     }
 
@@ -469,7 +469,7 @@ default Buffer writeBytes(byte[] source, int srcPos, int length) {
         for (int i = 0; i < length; i++) {
             setByte(woff + i, source[srcPos + i]);
         }
-        skipWritable(length);
+        skipWritableBytes(length);
         return this;
     }
 
@@ -519,7 +519,7 @@ default Buffer writeBytes(ByteBuffer source) {
     default Buffer readBytes(ByteBuffer destination) {
         int byteCount = destination.remaining();
         copyInto(readerOffset(), destination, destination.position(), byteCount);
-        skipReadable(byteCount);
+        skipReadableBytes(byteCount);
         destination.position(destination.limit());
         return this;
     }

buffer/src/main/java/io/netty5/buffer/api/BufferAllocator.java

@@ -263,7 +263,7 @@ default Buffer copyOf(ByteBuffer buffer) {
             duplicate.position(length + duplicate.position());
             return true;
         });
-        copy.skipWritable(bytesToCopy);
+        copy.skipWritableBytes(bytesToCopy);
         return copy;
     }
 

buffer/src/main/java/io/netty5/buffer/api/BufferStub.java

@@ -55,8 +55,8 @@ public int readerOffset() {
     }
 
     @Override
-    public Buffer skipReadable(int delta) {
-        delegate.skipReadable(delta);
+    public Buffer skipReadableBytes(int delta) {
+        delegate.skipReadableBytes(delta);
         return this;
     }
 
@@ -72,8 +72,8 @@ public int writerOffset() {
     }
 
     @Override
-    public Buffer skipWritable(int delta) {
-        delegate.skipWritable(delta);
+    public Buffer skipWritableBytes(int delta) {
+        delegate.skipWritableBytes(delta);
         return this;
     }
 

buffer/src/main/java/io/netty5/buffer/api/CompositeBuffer.java

@@ -180,13 +180,13 @@ static boolean isComposite(Buffer composite) {
     CompositeBuffer writerOffset(int offset);
 
     @Override
-    default CompositeBuffer skipReadable(int delta) {
-        return (CompositeBuffer) Buffer.super.skipReadable(delta);
+    default CompositeBuffer skipReadableBytes(int delta) {
+        return (CompositeBuffer) Buffer.super.skipReadableBytes(delta);
     }
 
     @Override
-    default CompositeBuffer skipWritable(int delta) {
-        return (CompositeBuffer) Buffer.super.skipWritable(delta);
+    default CompositeBuffer skipWritableBytes(int delta) {
+        return (CompositeBuffer) Buffer.super.skipWritableBytes(delta);
     }
 
     @Override

buffer/src/main/java/io/netty5/buffer/api/DefaultCompositeBuffer.java

@@ -553,7 +553,7 @@ public int transferTo(WritableByteChannel channel, int length) throws IOExceptio
                 }
             }
         } finally {
-            skipReadable(totalBytesWritten);
+            skipReadableBytes(totalBytesWritten);
         }
         return totalBytesWritten;
     }
@@ -591,7 +591,7 @@ public int transferFrom(FileChannel channel, long position, int length) throws I
             }
         } finally {
             if (totalBytesRead > 0) { // Don't skipWritable if total is 0 or -1
-                skipWritable(totalBytesRead);
+                skipWritableBytes(totalBytesRead);
             }
         }
         return totalBytesRead;
@@ -633,7 +633,7 @@ public int transferFrom(ReadableByteChannel channel, int length) throws IOExcept
             }
         } finally {
             if (totalBytesRead > 0) { // Don't skipWritable if total is 0 or -1
-                skipWritable(totalBytesRead);
+                skipWritableBytes(totalBytesRead);
             }
         }
         return totalBytesRead;
@@ -1044,7 +1044,7 @@ public <E extends Exception> int forEachReadable(int initialIndex, ReadableCompo
                 int roffAfter = buf.readerOffset();
                 if (roffAfter != roffBefore) { // Check if ReadableComponent.skipReadable was called.
                     buf.readerOffset(roffBefore); // Reset component offset.
-                    skipReadable(roffAfter - roffBefore); // Then move *composite* buffer offset.
+                    skipReadableBytes(roffAfter - roffBefore); // Then move *composite* buffer offset.
                 }
                 if (count > 0) {
                     visited += count;
@@ -1081,7 +1081,7 @@ public <E extends Exception> int forEachWritable(int initialIndex, WritableCompo
                 int woffAfter = buf.writerOffset();
                 if (woffAfter != woffBefore) { // Check if WritableComponent.skipWritable was called.
                     buf.writerOffset(woffBefore);
-                    skipWritable(woffAfter - woffBefore);
+                    skipWritableBytes(woffAfter - woffBefore);
                 }
                 if (count > 0) {
                     visited += count;
@@ -2147,8 +2147,8 @@ public ByteCursor openCursor() {
         }
 
         @Override
-        public ReadableComponent skipReadable(int byteCount) {
-            ((ReadableComponent) currentComponent).skipReadable(byteCount);
+        public ReadableComponent skipReadableBytes(int byteCount) {
+            ((ReadableComponent) currentComponent).skipReadableBytes(byteCount);
             compositeBuffer.readerOffset(pastOffset + currentReadSkip + byteCount);
             currentReadSkip += byteCount; // This needs to be after the bounds-checks.
             return this;
@@ -2190,8 +2190,8 @@ public ByteBuffer writableBuffer() {
         }
 
         @Override
-        public WritableComponent skipWritable(int byteCount) {
-            ((WritableComponent) currentComponent).skipWritable(byteCount);
+        public WritableComponent skipWritableBytes(int byteCount) {
+            ((WritableComponent) currentComponent).skipWritableBytes(byteCount);
             compositeBuffer.writerOffset(pastOffset + currentWriteSkip + byteCount);
             currentWriteSkip += byteCount; // This needs to be after the bounds-checks.
             return this;

buffer/src/main/java/io/netty5/buffer/api/MemoryManager.java

@@ -144,7 +144,7 @@ static Buffer unsafeWrap(byte[] array) {
         ManagedBufferAllocator allocator = new ManagedBufferAllocator(manager, false);
         WrappingAllocation allocationType = new WrappingAllocation(array);
         Buffer buffer = manager.allocateShared(allocator, array.length, ArcDrop::wrap, allocationType);
-        buffer.skipWritable(array.length);
+        buffer.skipWritableBytes(array.length);
         return buffer.makeReadOnly();
     }
 

buffer/src/main/java/io/netty5/buffer/api/ReadableComponent.java

@@ -109,7 +109,7 @@ public interface ReadableComponent {
      *
      * @param byteCount The number of bytes read from this component.
      * @return itself.
-     * @see Buffer#skipReadable(int)
+     * @see Buffer#skipReadableBytes(int)
      */
-    ReadableComponent skipReadable(int byteCount);
+    ReadableComponent skipReadableBytes(int byteCount);
 }

buffer/src/main/java/io/netty5/buffer/api/WritableComponent.java

@@ -84,7 +84,7 @@ public interface WritableComponent {
      *
      * @param byteCount The number of bytes written to this component.
      * @return itself.
-     * @see Buffer#skipWritable(int)
+     * @see Buffer#skipWritableBytes(int)
      */
-    WritableComponent skipWritable(int byteCount);
+    WritableComponent skipWritableBytes(int byteCount);
 }

buffer/src/main/java/io/netty5/buffer/api/adaptor/ByteBufBuffer.java

@@ -283,15 +283,15 @@ public int transferTo(WritableByteChannel channel, int length) throws IOExceptio
             GatheringByteChannel gatheringByteChannel = (GatheringByteChannel) channel;
             int bytesWritten = delegate.getBytes(readerOffset(), gatheringByteChannel, length);
             if (bytesWritten > 0) {
-                skipReadable(bytesWritten);
+                skipReadableBytes(bytesWritten);
             }
             return bytesWritten;
         }
         ByteBuffer buf = ByteBuffer.allocateDirect(Math.min(length, readableBytes()));
         copyInto(readerOffset(), buf, 0, buf.remaining());
         int bytesWritten = channel.write(buf);
         if (bytesWritten > 0) {
-            skipReadable(bytesWritten);
+            skipReadableBytes(bytesWritten);
         }
         return bytesWritten;
     }
@@ -315,7 +315,7 @@ public int transferFrom(FileChannel channel, long position, int length) throws I
         }
         int bytesRead = delegate.setBytes(writerOffset(), channel, position, length);
         if (bytesRead > 0) { // Don't skipWritable if bytesRead is 0 or -1
-            skipWritable(bytesRead);
+            skipWritableBytes(bytesRead);
         }
         return bytesRead;
     }
@@ -342,7 +342,7 @@ public int transferFrom(ReadableByteChannel channel, int length) throws IOExcept
             ScatteringByteChannel scatteringByteChannel = (ScatteringByteChannel) channel;
             int bytesRead = delegate.setBytes(writerOffset(), scatteringByteChannel, length);
             if (bytesRead > 0) {
-                skipWritable(bytesRead);
+                skipWritableBytes(bytesRead);
             }
             return bytesRead;
         }
@@ -467,7 +467,7 @@ public Buffer copy(int offset, int length, boolean readOnly) {
         Buffer copy = control.getAllocator().allocate(length);
         try {
             copyInto(offset, copy, 0, length);
-            copy.skipWritable(length);
+            copy.skipWritableBytes(length);
             if (readOnly) {
                 copy.makeReadOnly();
             }
@@ -1329,8 +1329,8 @@ public ByteCursor openCursor() {
         }
 
         @Override
-        public ReadableComponent skipReadable(int byteCount) {
-            buffer.skipReadable(byteCount);
+        public ReadableComponent skipReadableBytes(int byteCount) {
+            buffer.skipReadableBytes(byteCount);
             int delta = buffer.readerOffset() - startBufferReaderOffset;
             byteBuffer.position(startByteBufferPosition + delta);
             return this;
@@ -1398,8 +1398,8 @@ public ByteBuffer writableBuffer() {
         }
 
         @Override
-        public WritableComponent skipWritable(int byteCount) {
-            buffer.skipWritable(byteCount);
+        public WritableComponent skipWritableBytes(int byteCount) {
+            buffer.skipWritableBytes(byteCount);
             int delta = buffer.writerOffset() - startBufferWriterOffset;
             byteBuffer.position(startByteBufferPosition + delta);
             return this;

buffer/src/main/java/io/netty5/buffer/api/bytebuffer/NioBuffer.java

@@ -141,13 +141,13 @@ public int writableBytes() {
     }
 
     @Override
-    public NioBuffer skipReadable(int delta) {
-        return (NioBuffer) super.skipReadable(delta);
+    public NioBuffer skipReadableBytes(int delta) {
+        return (NioBuffer) super.skipReadableBytes(delta);
     }
 
     @Override
-    public NioBuffer skipWritable(int delta) {
-        return (NioBuffer) super.skipWritable(delta);
+    public NioBuffer skipWritableBytes(int delta) {
+        return (NioBuffer) super.skipWritableBytes(delta);
     }
 
     @Override
@@ -300,7 +300,7 @@ public int transferTo(WritableByteChannel channel, int length) throws IOExceptio
         }
         checkGet(readerOffset(), length);
         int bytesWritten = channel.write(readableBuffer().limit(length));
-        skipReadable(bytesWritten);
+        skipReadableBytes(bytesWritten);
         return bytesWritten;
     }
 
@@ -321,7 +321,7 @@ public int transferFrom(FileChannel channel, long position, int length) throws I
         checkSet(writerOffset(), length);
         int bytesRead = channel.read(writableBuffer().limit(length), position);
         if (bytesRead > 0) { // Don't skipWritable if bytesRead is 0 or -1
-            skipWritable(bytesRead);
+            skipWritableBytes(bytesRead);
         }
         return bytesRead;
     }
@@ -341,7 +341,7 @@ public int transferFrom(ReadableByteChannel channel, int length) throws IOExcept
         checkSet(writerOffset(), length);
         int bytesRead = channel.read(writableBuffer().limit(length));
         if (bytesRead != -1) {
-            skipWritable(bytesRead);
+            skipWritableBytes(bytesRead);
         }
         return bytesRead;
     }

buffer/src/main/java/io/netty5/buffer/api/internal/Statics.java

@@ -261,7 +261,7 @@ static void unsafeSetDrop(ResourceSupport<?, ?> obj, Drop<?> replacement) {
 
     static CharSequence readCharSequence(Buffer source, int length, Charset charset) {
         final CharSequence charSequence = copyToCharSequence(source, source.readerOffset(), length, charset);
-        source.skipReadable(length);
+        source.skipReadableBytes(length);
         return charSequence;
     }
 

buffer/src/main/java/io/netty5/buffer/api/unsafe/UnsafeBuffer.java

@@ -153,13 +153,13 @@ public int writableBytes() {
     }
 
     @Override
-    public UnsafeBuffer skipReadable(int delta) {
-        return (UnsafeBuffer) super.skipReadable(delta);
+    public UnsafeBuffer skipReadableBytes(int delta) {
+        return (UnsafeBuffer) super.skipReadableBytes(delta);
     }
 
     @Override
-    public UnsafeBuffer skipWritable(int delta) {
-        return (UnsafeBuffer) super.skipWritable(delta);
+    public UnsafeBuffer skipWritableBytes(int delta) {
+        return (UnsafeBuffer) super.skipWritableBytes(delta);
     }
 
     @Override
@@ -333,7 +333,7 @@ public int transferTo(WritableByteChannel channel, int length) throws IOExceptio
         }
         checkGet(readerOffset(), length);
         int bytesWritten = channel.write(readableBuffer().limit(length));
-        skipReadable(bytesWritten);
+        skipReadableBytes(bytesWritten);
         return bytesWritten;
     }
 
@@ -354,7 +354,7 @@ public int transferFrom(FileChannel channel, long position, int length) throws I
         checkSet(writerOffset(), length);
         int bytesRead = channel.read(writableBuffer().limit(length), position);
         if (bytesRead > 0) { // Don't skipWritable if bytesRead is 0 or -1
-            skipWritable(bytesRead);
+            skipWritableBytes(bytesRead);
         }
         return bytesRead;
     }
@@ -374,7 +374,7 @@ public int transferFrom(ReadableByteChannel channel, int length) throws IOExcept
         checkSet(writerOffset(), length);
         int bytesRead = channel.read(writableBuffer().limit(length));
         if (bytesRead != -1) {
-            skipWritable(bytesRead);
+            skipWritableBytes(bytesRead);
         }
         return bytesRead;
     }

buffer/src/test/java/io/netty5/buffer/api/tests/BufferBulkAccessTest.java

@@ -312,7 +312,7 @@ public void directBuffersMustAdjustReadableWritableNativeAddress(Fixture fixture
                 long addr = component.writableNativeAddress();
                 assertThat(addr).isNotZero();
                 component.writableBuffer().putInt(0x01020304);
-                component.skipWritable(4);
+                component.skipWritableBytes(4);
                 assertThat(component.writableBytes()).isEqualTo(4);
                 assertThat(component.writableNativeAddress()).isEqualTo(addr + 4);
                 return true;
@@ -326,11 +326,11 @@ public void directBuffersMustAdjustReadableWritableNativeAddress(Fixture fixture
                 long addr = component.readableNativeAddress();
                 assertThat(addr).isNotZero();
                 assertThat(component.readableBuffer().get()).isEqualTo((byte) 0x01);
-                component.skipReadable(1);
+                component.skipReadableBytes(1);
                 assertThat(component.readableBytes()).isEqualTo(3);
                 assertThat(component.readableNativeAddress()).isEqualTo(addr + 1);
                 assertThat(component.readableBuffer().get()).isEqualTo((byte) 0x02);
-                component.skipReadable(1);
+                component.skipReadableBytes(1);
                 return true;
             });