andreacavalli/netty5
1
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

Replace .readable() and .writable() to .isReadable() and .isWritable()

Browse Source
This commit is contained in:
Trustin Lee 2013-01-31 23:39:57 +09:00 committed by Norman Maurer
parent 42c65cca3a
commit 2ec932798f
28 changed files with 125 additions and 123 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
buffer/src/test/java/io/netty/buffer/AbstractByteBufTest.java
View File

@ -473,7 +473,7 @@ public abstract class AbstractByteBufTest {
@Test
public void testSetZero() {
buffer.clear();
while (buffer.writable()) {
while (buffer.isWritable()) {
buffer.writeByte((byte) 0xFF);
}
@ -494,26 +494,26 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity(); i ++) {
byte value = (byte) random.nextInt();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeByte(value);
}
assertEquals(0, buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
random.setSeed(seed);
for (int i = 0; i < buffer.capacity(); i ++) {
byte value = (byte) random.nextInt();
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readByte());
}
assertEquals(buffer.capacity(), buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.readable());
assertFalse(buffer.writable());
assertFalse(buffer.isReadable());
assertFalse(buffer.isWritable());
}
@Test
@ -522,26 +522,26 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity(); i ++) {
byte value = (byte) random.nextInt();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeByte(value);
}
assertEquals(0, buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
random.setSeed(seed);
for (int i = 0; i < buffer.capacity(); i ++) {
int value = random.nextInt() & 0xFF;
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readUnsignedByte());
}
assertEquals(buffer.capacity(), buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.readable());
assertFalse(buffer.writable());
assertFalse(buffer.isReadable());
assertFalse(buffer.isWritable());
}
@Test
@ -550,26 +550,26 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity(); i += 2) {
short value = (short) random.nextInt();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeShort(value);
}
assertEquals(0, buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
random.setSeed(seed);
for (int i = 0; i < buffer.capacity(); i += 2) {
short value = (short) random.nextInt();
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readShort());
}
assertEquals(buffer.capacity(), buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.readable());
assertFalse(buffer.writable());
assertFalse(buffer.isReadable());
assertFalse(buffer.isWritable());
}
@Test
@ -578,26 +578,26 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity(); i += 2) {
short value = (short) random.nextInt();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeShort(value);
}
assertEquals(0, buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
random.setSeed(seed);
for (int i = 0; i < buffer.capacity(); i += 2) {
int value = random.nextInt() & 0xFFFF;
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readUnsignedShort());
}
assertEquals(buffer.capacity(), buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.readable());
assertFalse(buffer.writable());
assertFalse(buffer.isReadable());
assertFalse(buffer.isWritable());
}
@Test
@ -606,7 +606,7 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity() / 3 * 3; i += 3) {
int value = random.nextInt();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeMedium(value);
}
@ -618,7 +618,7 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity() / 3 * 3; i += 3) {
int value = random.nextInt() << 8 >> 8;
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readMedium());
}
@ -634,7 +634,7 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity() / 3 * 3; i += 3) {
int value = random.nextInt() & 0x00FFFFFF;
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeMedium(value);
}
@ -646,7 +646,7 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity() / 3 * 3; i += 3) {
int value = random.nextInt() & 0x00FFFFFF;
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readUnsignedMedium());
}
@ -662,26 +662,26 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity(); i += 4) {
int value = random.nextInt();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeInt(value);
}
assertEquals(0, buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
random.setSeed(seed);
for (int i = 0; i < buffer.capacity(); i += 4) {
int value = random.nextInt();
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readInt());
}
assertEquals(buffer.capacity(), buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.readable());
assertFalse(buffer.writable());
assertFalse(buffer.isReadable());
assertFalse(buffer.isWritable());
}
@Test
@ -690,26 +690,26 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity(); i += 4) {
int value = random.nextInt();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeInt(value);
}
assertEquals(0, buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
random.setSeed(seed);
for (int i = 0; i < buffer.capacity(); i += 4) {
long value = random.nextInt() & 0xFFFFFFFFL;
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readUnsignedInt());
}
assertEquals(buffer.capacity(), buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.readable());
assertFalse(buffer.writable());
assertFalse(buffer.isReadable());
assertFalse(buffer.isWritable());
}
@Test
@ -718,26 +718,26 @@ public abstract class AbstractByteBufTest {
for (int i = 0; i < buffer.capacity(); i += 8) {
long value = random.nextLong();
assertEquals(i, buffer.writerIndex());
assertTrue(buffer.writable());
assertTrue(buffer.isWritable());
buffer.writeLong(value);
}
assertEquals(0, buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
random.setSeed(seed);
for (int i = 0; i < buffer.capacity(); i += 8) {
long value = random.nextLong();
assertEquals(i, buffer.readerIndex());
assertTrue(buffer.readable());
assertTrue(buffer.isReadable());
assertEquals(value, buffer.readLong());
}
assertEquals(buffer.capacity(), buffer.readerIndex());
assertEquals(buffer.capacity(), buffer.writerIndex());
assertFalse(buffer.readable());
assertFalse(buffer.writable());
assertFalse(buffer.isReadable());
assertFalse(buffer.isWritable());
}
@Test
@ -1254,7 +1254,7 @@ public abstract class AbstractByteBufTest {
}
buffer.clear();
while (buffer.writable()) {
while (buffer.isWritable()) {
buffer.writeByte((byte) 0xFF);
}

3
buffer/src/test/java/io/netty/buffer/AbstractCompositeByteBufTest.java
View File

@ -28,6 +28,7 @@ import static org.junit.Assert.*;
/**
* An abstract test class for composite channel buffers
*/
@SuppressWarnings("ZeroLengthArrayAllocation")
public abstract class AbstractCompositeByteBufTest extends
AbstractByteBufTest {
@ -76,7 +77,7 @@ public abstract class AbstractCompositeByteBufTest extends
assertEquals(length, buffer.capacity());
assertEquals(length, buffer.readableBytes());
assertFalse(buffer.writable());
assertFalse(buffer.isWritable());
buffer.writerIndex(0);
return buffer;
}

7
buffer/src/test/java/io/netty/buffer/ByteBufStreamTest.java
View File

@ -15,17 +15,18 @@
*/
package io.netty.buffer;
import static org.junit.Assert.*;
import org.junit.Test;
import java.io.EOFException;
import java.nio.charset.Charset;
import org.junit.Test;
import static org.junit.Assert.*;
/**
* Tests channel buffer streams
*/
@SuppressWarnings("ZeroLengthArrayAllocation")
public class ByteBufStreamTest {
@Test
@ -93,7 +94,7 @@ public class ByteBufStreamTest {
in.mark(Integer.MAX_VALUE);
assertEquals(buf.writerIndex(), in.skip(Long.MAX_VALUE));
assertFalse(buf.readable());
assertFalse(buf.isReadable());
in.reset();
assertEquals(0, buf.readerIndex());

28
buffer/src/test/java/io/netty/buffer/UnpooledTest.java
View File

@ -409,7 +409,7 @@ public class UnpooledTest {
ByteBuf buffer = copyInt(42);
assertEquals(4, buffer.capacity());
assertEquals(42, buffer.readInt());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
}
@Test
@ -418,7 +418,7 @@ public class UnpooledTest {
assertEquals(8, buffer.capacity());
assertEquals(1, buffer.readInt());
assertEquals(4, buffer.readInt());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyInt(null).capacity());
assertEquals(0, Unpooled.copyInt(new int[0]).capacity());
@ -429,7 +429,7 @@ public class UnpooledTest {
ByteBuf buffer = copyShort(42);
assertEquals(2, buffer.capacity());
assertEquals(42, buffer.readShort());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
}
@Test
@ -438,7 +438,7 @@ public class UnpooledTest {
assertEquals(4, buffer.capacity());
assertEquals(1, buffer.readShort());
assertEquals(4, buffer.readShort());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyShort((short[]) null).capacity());
assertEquals(0, Unpooled.copyShort(new short[0]).capacity());
@ -450,7 +450,7 @@ public class UnpooledTest {
assertEquals(4, buffer.capacity());
assertEquals(1, buffer.readShort());
assertEquals(4, buffer.readShort());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyShort((int[]) null).capacity());
assertEquals(0, Unpooled.copyShort(new int[0]).capacity());
@ -461,7 +461,7 @@ public class UnpooledTest {
ByteBuf buffer = copyMedium(42);
assertEquals(3, buffer.capacity());
assertEquals(42, buffer.readMedium());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
}
@Test
@ -470,7 +470,7 @@ public class UnpooledTest {
assertEquals(6, buffer.capacity());
assertEquals(1, buffer.readMedium());
assertEquals(4, buffer.readMedium());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyMedium(null).capacity());
assertEquals(0, Unpooled.copyMedium(new int[0]).capacity());
@ -481,7 +481,7 @@ public class UnpooledTest {
ByteBuf buffer = copyLong(42);
assertEquals(8, buffer.capacity());
assertEquals(42, buffer.readLong());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
}
@Test
@ -490,7 +490,7 @@ public class UnpooledTest {
assertEquals(16, buffer.capacity());
assertEquals(1, buffer.readLong());
assertEquals(4, buffer.readLong());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyLong(null).capacity());
assertEquals(0, Unpooled.copyLong(new long[0]).capacity());
@ -501,7 +501,7 @@ public class UnpooledTest {
ByteBuf buffer = copyFloat(42);
assertEquals(4, buffer.capacity());
assertEquals(42, buffer.readFloat(), 0.01);
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
}
@Test
@ -510,7 +510,7 @@ public class UnpooledTest {
assertEquals(8, buffer.capacity());
assertEquals(1, buffer.readFloat(), 0.01);
assertEquals(4, buffer.readFloat(), 0.01);
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyFloat(null).capacity());
assertEquals(0, Unpooled.copyFloat(new float[0]).capacity());
@ -521,7 +521,7 @@ public class UnpooledTest {
ByteBuf buffer = copyDouble(42);
assertEquals(8, buffer.capacity());
assertEquals(42, buffer.readDouble(), 0.01);
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
}
@Test
@ -530,7 +530,7 @@ public class UnpooledTest {
assertEquals(16, buffer.capacity());
assertEquals(1, buffer.readDouble(), 0.01);
assertEquals(4, buffer.readDouble(), 0.01);
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyDouble(null).capacity());
assertEquals(0, Unpooled.copyDouble(new double[0]).capacity());
@ -542,7 +542,7 @@ public class UnpooledTest {
assertEquals(2, buffer.capacity());
assertTrue(buffer.readBoolean());
assertFalse(buffer.readBoolean());
assertFalse(buffer.readable());
assertFalse(buffer.isReadable());
assertEquals(0, Unpooled.copyBoolean(null).capacity());
assertEquals(0, Unpooled.copyBoolean(new boolean[0]).capacity());

2
codec-http/src/main/java/io/netty/handler/codec/http/HttpContentDecoder.java
View File

@ -134,7 +134,7 @@ public abstract class HttpContentDecoder extends MessageToMessageDecoder<Object>
// Generate an additional chunk if the decoder produced
// the last product on closure,
if (lastProduct.readable()) {
if (lastProduct.isReadable()) {
if (header == null) {
return new Object[] { new DefaultHttpContent(newContent), new DefaultLastHttpContent(lastProduct)};
} else {

4
codec-http/src/main/java/io/netty/handler/codec/http/HttpContentEncoder.java
View File

@ -85,7 +85,7 @@ public abstract class HttpContentEncoder extends MessageToMessageCodec<HttpMessa
}
// handle the case of single complete message without content
if (msg instanceof FullHttpMessage && !((FullHttpMessage) msg).data().readable()) {
if (msg instanceof FullHttpMessage && !((FullHttpMessage) msg).data().isReadable()) {
// Remove content encoding
String acceptEncoding = acceptEncodingQueue.poll();
@ -200,7 +200,7 @@ public abstract class HttpContentEncoder extends MessageToMessageCodec<HttpMessa
// Generate an additional chunk if the decoder produced
// the last product on closure,
if (lastProduct.readable()) {
if (lastProduct.isReadable()) {
if (header == null) {
return new Object[] { new DefaultHttpContent(newContent), new DefaultLastHttpContent(lastProduct)};
} else {

2
codec-http/src/main/java/io/netty/handler/codec/http/HttpObjectAggregator.java
View File

@ -169,7 +169,7 @@ public class HttpObjectAggregator extends MessageToMessageDecoder<HttpObject> {
}
// Append the content of the chunk
if (chunk.data().readable()) {
if (chunk.data().isReadable()) {
content.addComponent(chunk.data());
content.writerIndex(content.writerIndex() + chunk.data().readableBytes());
} else {

4
codec-http/src/main/java/io/netty/handler/codec/http/HttpObjectDecoder.java
View File

@ -253,7 +253,7 @@ public abstract class HttpObjectDecoder extends ReplayingDecoder<HttpObjectDecod
toRead = maxChunkSize;
}
ByteBuf content = buffer.readBytes(toRead);
if (!buffer.readable()) {
if (!buffer.isReadable()) {
reset();
return new DefaultLastHttpContent(content);
}
@ -432,7 +432,7 @@ public abstract class HttpObjectDecoder extends ReplayingDecoder<HttpObjectDecod
ByteBuf content = this.content;
LastHttpContent httpContent;
if (content == null || !content.readable()) {
if (content == null || !content.isReadable()) {
httpContent = LastHttpContent.EMPTY_LAST_CONTENT;
} else {
httpContent = new DefaultLastHttpContent(content);

28
codec-http/src/main/java/io/netty/handler/codec/http/multipart/HttpPostRequestDecoder.java
View File

@ -449,7 +449,7 @@ public class HttpPostRequestDecoder {
}
boolean contRead = true;
try {
while (undecodedChunk.readable() && contRead) {
while (undecodedChunk.isReadable() && contRead) {
char read = (char) undecodedChunk.readUnsignedByte();
currentpos++;
switch (currentStatus) {
@ -482,7 +482,7 @@ public class HttpPostRequestDecoder {
firstpos = currentpos;
contRead = true;
} else if (read == HttpConstants.CR) {
if (undecodedChunk.readable()) {
if (undecodedChunk.isReadable()) {
read = (char) undecodedChunk.readUnsignedByte();
currentpos++;
if (read == HttpConstants.LF) {
@ -1188,7 +1188,7 @@ public class HttpPostRequestDecoder {
try {
ByteBuf line = buffer(64);
while (undecodedChunk.readable()) {
while (undecodedChunk.isReadable()) {
byte nextByte = undecodedChunk.readByte();
if (nextByte == HttpConstants.CR) {
nextByte = undecodedChunk.readByte();
@ -1276,7 +1276,7 @@ public class HttpPostRequestDecoder {
StringBuilder sb = new StringBuilder(64);
int delimiterPos = 0;
int len = delimiter.length();
while (undecodedChunk.readable() && delimiterPos < len) {
while (undecodedChunk.isReadable() && delimiterPos < len) {
byte nextByte = undecodedChunk.readByte();
if (nextByte == delimiter.charAt(delimiterPos)) {
delimiterPos++;
@ -1288,7 +1288,7 @@ public class HttpPostRequestDecoder {
}
}
// Now check if either opening delimiter or closing delimiter
if (undecodedChunk.readable()) {
if (undecodedChunk.isReadable()) {
byte nextByte = undecodedChunk.readByte();
// first check for opening delimiter
if (nextByte == HttpConstants.CR) {
@ -1310,7 +1310,7 @@ public class HttpPostRequestDecoder {
if (nextByte == '-') {
sb.append('-');
// now try to find if CRLF or LF there
if (undecodedChunk.readable()) {
if (undecodedChunk.isReadable()) {
nextByte = undecodedChunk.readByte();
if (nextByte == HttpConstants.CR) {
nextByte = undecodedChunk.readByte();
@ -1484,7 +1484,7 @@ public class HttpPostRequestDecoder {
int index = 0;
int lastPosition = undecodedChunk.readerIndex();
boolean found = false;
while (undecodedChunk.readable()) {
while (undecodedChunk.isReadable()) {
byte nextByte = undecodedChunk.readByte();
if (newLine) {
// Check the delimiter
@ -1500,7 +1500,7 @@ public class HttpPostRequestDecoder {
index = 0;
// continue until end of line
if (nextByte == HttpConstants.CR) {
if (undecodedChunk.readable()) {
if (undecodedChunk.isReadable()) {
nextByte = undecodedChunk.readByte();
if (nextByte == HttpConstants.LF) {
newLine = true;
@ -1520,7 +1520,7 @@ public class HttpPostRequestDecoder {
} else {
// continue until end of line
if (nextByte == HttpConstants.CR) {
if (undecodedChunk.readable()) {
if (undecodedChunk.isReadable()) {
nextByte = undecodedChunk.readByte();
if (nextByte == HttpConstants.LF) {
newLine = true;
@ -1684,7 +1684,7 @@ public class HttpPostRequestDecoder {
int index = 0;
int lastPosition = undecodedChunk.readerIndex();
boolean found = false;
while (undecodedChunk.readable()) {
while (undecodedChunk.isReadable()) {
byte nextByte = undecodedChunk.readByte();
if (newLine) {
// Check the delimiter
@ -1700,7 +1700,7 @@ public class HttpPostRequestDecoder {
index = 0;
// continue until end of line
if (nextByte == HttpConstants.CR) {
if (undecodedChunk.readable()) {
if (undecodedChunk.isReadable()) {
nextByte = undecodedChunk.readByte();
if (nextByte == HttpConstants.LF) {
newLine = true;
@ -1719,7 +1719,7 @@ public class HttpPostRequestDecoder {
} else {
// continue until end of line
if (nextByte == HttpConstants.CR) {
if (undecodedChunk.readable()) {
if (undecodedChunk.isReadable()) {
nextByte = undecodedChunk.readByte();
if (nextByte == HttpConstants.LF) {
newLine = true;
@ -1899,12 +1899,12 @@ public class HttpPostRequestDecoder {
* @return True if one empty line was skipped
*/
private boolean skipOneLine() {
if (!undecodedChunk.readable()) {
if (!undecodedChunk.isReadable()) {
return false;
}
byte nextByte = undecodedChunk.readByte();
if (nextByte == HttpConstants.CR) {
if (!undecodedChunk.readable()) {
if (!undecodedChunk.isReadable()) {
undecodedChunk.readerIndex(undecodedChunk.readerIndex() - 1);
return false;
}

2
codec-http/src/main/java/io/netty/handler/codec/http/websocketx/WebSocket08FrameDecoder.java
View File

@ -421,7 +421,7 @@ public class WebSocket08FrameDecoder extends ReplayingDecoder<WebSocket08FrameDe
}
// May have UTF-8 message
if (buffer.readable()) {
if (buffer.isReadable()) {
try {
new UTF8Output(buffer);

4
codec/src/main/java/io/netty/handler/codec/ByteToByteDecoder.java
View File

@ -75,7 +75,7 @@ public abstract class ByteToByteDecoder extends ChannelInboundByteHandlerAdapter
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
ByteBuf in = ctx.inboundByteBuffer();
ByteBuf out = ctx.nextInboundByteBuffer();
if (!in.readable()) {
if (!in.isReadable()) {
callDecode(ctx, in, out);
}
@ -102,7 +102,7 @@ public abstract class ByteToByteDecoder extends ChannelInboundByteHandlerAdapter
*/
private void callDecode(ChannelHandlerContext ctx, ByteBuf in, ByteBuf out) {
int oldOutSize = out.readableBytes();
while (in.readable()) {
while (in.isReadable()) {
int oldInSize = in.readableBytes();
try {
decode(ctx, in, out);

2
codec/src/main/java/io/netty/handler/codec/ByteToByteEncoder.java
View File

@ -52,7 +52,7 @@ public abstract class ByteToByteEncoder extends ChannelOutboundByteHandlerAdapte
ByteBuf out = ctx.nextOutboundByteBuffer();
boolean encoded = false;
while (in.readable()) {
while (in.isReadable()) {
int oldInSize = in.readableBytes();
try {
encode(ctx, in, out);

4
codec/src/main/java/io/netty/handler/codec/ByteToMessageDecoder.java
View File

@ -83,7 +83,7 @@ public abstract class ByteToMessageDecoder
@Override
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
ByteBuf in = ctx.inboundByteBuffer();
if (in.readable()) {
if (in.isReadable()) {
callDecode(ctx, in);
}
@ -106,7 +106,7 @@ public abstract class ByteToMessageDecoder
boolean wasNull = false;
boolean decoded = false;
while (in.readable()) {
while (in.isReadable()) {
try {
int oldInputLength = in.readableBytes();
Object o = decode(ctx, in);

2
codec/src/main/java/io/netty/handler/codec/DelimiterBasedFrameDecoder.java
View File

@ -326,7 +326,7 @@ public class DelimiterBasedFrameDecoder extends ByteToMessageDecoder {
if (delimiter == null) {
throw new NullPointerException("delimiter");
}
if (!delimiter.readable()) {
if (!delimiter.isReadable()) {
throw new IllegalArgumentException("empty delimiter");
}
}

6
codec/src/main/java/io/netty/handler/codec/ReplayingDecoder.java
View File

@ -248,7 +248,7 @@ import io.netty.util.internal.Signal;
* // Remove the first decoder (me)
* ctx.pipeline().remove(this);
*
* if (buf.readable()) {
* if (buf.isReadable()) {
* // Hand off the remaining data to the second decoder
* return new Object[] { firstMessage, buf.readBytes(<b>super.actualReadableBytes()</b>) };
* } else {
@ -362,7 +362,7 @@ public abstract class ReplayingDecoder<S> extends ByteToMessageDecoder {
public void channelInactive(ChannelHandlerContext ctx) throws Exception {
replayable.terminate();
ByteBuf in = cumulation;
if (in.readable()) {
if (in.isReadable()) {
callDecode(ctx, in);
}
@ -390,7 +390,7 @@ public abstract class ReplayingDecoder<S> extends ByteToMessageDecoder {
ByteBuf in = cumulation;
boolean decoded = false;
while (in.readable()) {
while (in.isReadable()) {
try {
int oldReaderIndex = checkpoint = in.readerIndex();
Object result = null;

3
codec/src/main/java/io/netty/handler/codec/ReplayingDecoderBuffer.java
View File

@ -143,6 +143,7 @@ final class ReplayingDecoderBuffer implements ByteBuf {
}
@Override
@Deprecated
public ByteBuf ensureWritableBytes(int writableBytes) {
throw new UnreplayableOperationException();
}
@ -395,6 +396,7 @@ final class ReplayingDecoderBuffer implements ByteBuf {
}
@Override
@Deprecated
public boolean readable() {
return isReadable();
}
@ -739,6 +741,7 @@ final class ReplayingDecoderBuffer implements ByteBuf {
}
@Override
@Deprecated
public boolean writable() {
return false;
}

4
codec/src/main/java/io/netty/handler/codec/compression/SnappyFramedDecoder.java
View File

@ -70,11 +70,11 @@ public class SnappyFramedDecoder extends ByteToByteDecoder {
@Override
protected void decode(ChannelHandlerContext ctx, ByteBuf in, ByteBuf out) throws Exception {
if (!in.readable()) {
if (!in.isReadable()) {
return;
}
while (in.readable()) {
while (in.isReadable()) {
if (chunkLength == 0) {
if (in.readableBytes() < 3) {
// We need to be at least able to read the chunk type identifier (one byte),

2
codec/src/main/java/io/netty/handler/codec/compression/SnappyFramedEncoder.java
View File

@ -47,7 +47,7 @@ public class SnappyFramedEncoder extends ByteToByteEncoder {
@Override
protected void encode(ChannelHandlerContext ctx, ByteBuf in, ByteBuf out) throws Exception {
if (!in.readable()) {
if (!in.isReadable()) {
return;
}

5
codec/src/main/java/io/netty/handler/codec/marshalling/ChannelBufferByteInput.java
View File

@ -16,11 +16,10 @@
package io.netty.handler.codec.marshalling;
import io.netty.buffer.ByteBuf;
import org.jboss.marshalling.ByteInput;
import java.io.IOException;
import org.jboss.marshalling.ByteInput;
/**
* {@link ByteInput} implementation which reads its data from a {@link ByteBuf}
*/
@ -44,7 +43,7 @@ class ChannelBufferByteInput implements ByteInput {
@Override
public int read() throws IOException {
if (buffer.readable()) {
if (buffer.isReadable()) {
return buffer.readByte() & 0xff;
}
return -1;

5
codec/src/main/java/io/netty/handler/codec/protobuf/ProtobufVarint32FrameDecoder.java
View File

@ -15,13 +15,12 @@
*/
package io.netty.handler.codec.protobuf;
import com.google.protobuf.CodedInputStream;
import io.netty.buffer.ByteBuf;
import io.netty.channel.ChannelHandlerContext;
import io.netty.handler.codec.ByteToMessageDecoder;
import io.netty.handler.codec.CorruptedFrameException;
import com.google.protobuf.CodedInputStream;
/**
* A decoder that splits the received {@link ByteBuf}s dynamically by the
* value of the Google Protocol Buffers
@ -47,7 +46,7 @@ public class ProtobufVarint32FrameDecoder extends ByteToMessageDecoder {
in.markReaderIndex();
final byte[] buf = new byte[5];
for (int i = 0; i < buf.length; i ++) {
if (!in.readable()) {
if (!in.isReadable()) {
in.resetReaderIndex();
return null;
}

7
codec/src/test/java/io/netty/handler/codec/ReplayingDecoderBufferTest.java
View File

@ -15,15 +15,14 @@
*/
package io.netty.handler.codec;
import static org.junit.Assert.assertEquals;
import static org.junit.Assert.assertTrue;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.Unpooled;
import io.netty.util.CharsetUtil;
import io.netty.util.internal.Signal;
import org.junit.Test;
import static org.junit.Assert.*;
public class ReplayingDecoderBufferTest {
/**
@ -76,7 +75,7 @@ public class ReplayingDecoderBufferTest {
@Test
public void testGetBoolean() {
ByteBuf buf = Unpooled.buffer(10);
while(buf.writable()) {
while(buf.isWritable()) {
buf.writeBoolean(true);
}
ReplayingDecoderBuffer buffer = new ReplayingDecoderBuffer(buf);

6
handler/src/test/java/io/netty/handler/stream/ChunkedWriteHandlerTest.java
View File

@ -15,7 +15,6 @@
*/
package io.netty.handler.stream;
import static org.junit.Assert.*;
import io.netty.buffer.ByteBuf;
import io.netty.buffer.MessageBuf;
import io.netty.buffer.Unpooled;
@ -24,6 +23,7 @@ import io.netty.channel.ChannelFutureListener;
import io.netty.channel.embedded.EmbeddedByteChannel;
import io.netty.channel.embedded.EmbeddedMessageChannel;
import io.netty.util.CharsetUtil;
import org.junit.Test;
import java.io.ByteArrayInputStream;
import java.io.File;
@ -32,7 +32,7 @@ import java.io.IOException;
import java.nio.channels.Channels;
import java.util.concurrent.atomic.AtomicBoolean;
import org.junit.Test;
import static org.junit.Assert.*;
public class ChunkedWriteHandlerTest {
private static final byte[] BYTES = new byte[1024 * 64];
@ -203,7 +203,7 @@ public class ChunkedWriteHandlerTest {
if (buffer == null) {
break;
}
while (buffer.readable()) {
while (buffer.isReadable()) {
assertEquals(BYTES[i++], buffer.readByte());
read++;
if (i == BYTES.length) {

6
transport-sctp/src/main/java/io/netty/handler/codec/sctp/SctpMessageCompletionHandler.java
View File

@ -66,13 +66,13 @@ public class SctpMessageCompletionHandler extends ChannelInboundMessageHandlerAd
frag = Unpooled.EMPTY_BUFFER;
}
if (isComplete && !frag.readable()) {
if (isComplete && !frag.isReadable()) {
//data chunk is not fragmented
handleAssembledMessage(ctx, msg);
} else if (!isComplete && frag.readable()) {
} else if (!isComplete && frag.isReadable()) {
//more message to complete
fragments.put(streamIdentifier, Unpooled.wrappedBuffer(frag, byteBuf));
} else if (isComplete && frag.readable()) {
} else if (isComplete && frag.isReadable()) {
//last message to complete
fragments.remove(streamIdentifier);
SctpMessage assembledMsg = new SctpMessage(

8
transport/src/main/java/io/netty/channel/DefaultChannelHandlerContext.java
View File

@ -198,7 +198,7 @@ final class DefaultChannelHandlerContext extends DefaultAttributeMap implements
}
void forwardBufferContent() {
if (hasOutboundByteBuffer() && outboundByteBuffer().readable()) {
if (hasOutboundByteBuffer() && outboundByteBuffer().isReadable()) {
nextOutboundByteBuffer().writeBytes(outboundByteBuffer());
flush();
}
@ -207,7 +207,7 @@ final class DefaultChannelHandlerContext extends DefaultAttributeMap implements
flush();
}
}
if (hasInboundByteBuffer() && inboundByteBuffer().readable()) {
if (hasInboundByteBuffer() && inboundByteBuffer().isReadable()) {
nextInboundByteBuffer().writeBytes(inboundByteBuffer());
fireInboundBufferUpdated();
}
@ -1833,7 +1833,7 @@ final class DefaultChannelHandlerContext extends DefaultAttributeMap implements
}
private void fill() {
if (!byteBuf.readable()) {
if (!byteBuf.isReadable()) {
return;
}
@ -1851,7 +1851,7 @@ final class DefaultChannelHandlerContext extends DefaultAttributeMap implements
}
private void flush(ByteBuf out) {
while (out.writable()) {
while (out.isWritable()) {
ByteBuf data = exchangeBuf.peek();
if (data == null) {
break;

6
transport/src/main/java/io/netty/channel/embedded/AbstractEmbeddedChannel.java
View File

@ -135,7 +135,7 @@ public abstract class AbstractEmbeddedChannel<O> extends AbstractChannel {
* Return received data from this {@link Channel}
*/
public Object readInbound() {
if (lastInboundByteBuffer.readable()) {
if (lastInboundByteBuffer.isReadable()) {
try {
return lastInboundByteBuffer.readBytes(lastInboundByteBuffer.readableBytes());
} finally {
@ -275,7 +275,7 @@ public abstract class AbstractEmbeddedChannel<O> extends AbstractChannel {
close();
runPendingTasks();
checkException();
return lastInboundByteBuffer().readable() || !lastInboundMessageBuffer().isEmpty() ||
return lastInboundByteBuffer().isReadable() || !lastInboundMessageBuffer().isEmpty() ||
hasReadableOutboundBuffer();
}
@ -291,7 +291,7 @@ public abstract class AbstractEmbeddedChannel<O> extends AbstractChannel {
pipeline().fireInboundBufferUpdated();
runPendingTasks();
checkException();
return lastInboundByteBuffer().readable() || !lastInboundMessageBuffer().isEmpty();
return lastInboundByteBuffer().isReadable() || !lastInboundMessageBuffer().isEmpty();
}
/**

4
transport/src/main/java/io/netty/channel/embedded/EmbeddedByteChannel.java
View File

@ -55,7 +55,7 @@ public class EmbeddedByteChannel extends AbstractEmbeddedChannel<ByteBuf> {
@Override
public ByteBuf readOutbound() {
if (!lastOutboundBuffer().readable()) {
if (!lastOutboundBuffer().isReadable()) {
return null;
}
try {
@ -72,7 +72,7 @@ public class EmbeddedByteChannel extends AbstractEmbeddedChannel<ByteBuf> {
@Override
protected boolean hasReadableOutboundBuffer() {
return lastOutboundBuffer().readable();
return lastOutboundBuffer().isReadable();
}
@Override

6
transport/src/main/java/io/netty/channel/socket/aio/AioSocketChannel.java
View File

@ -239,7 +239,7 @@ public class AioSocketChannel extends AbstractAioChannel implements SocketChanne
inDoFlushByteBuffer = true;
try {
if (buf.readable()) {
if (buf.isReadable()) {
for (;;) {
if (buf.isFreed()) {
break;
@ -273,7 +273,7 @@ public class AioSocketChannel extends AbstractAioChannel implements SocketChanne
// JDK performed the write operation immediately and notified the handler.
// We know this because we set asyncWriteInProgress to false in the handler.
if (!buf.readable()) {
if (!buf.isReadable()) {
// There's nothing left in the buffer. No need to retry writing.
break;
}
@ -386,7 +386,7 @@ public class AioSocketChannel extends AbstractAioChannel implements SocketChanne
return;
}
if (buf.readable()) {
if (buf.isReadable()) {
channel.unsafe().flushNow();
}
}

6
transport/src/main/java/io/netty/channel/socket/nio/AbstractNioByteChannel.java
View File

@ -86,7 +86,7 @@ public abstract class AbstractNioByteChannel extends AbstractNioChannel {
if (read) {
read = false;
pipeline.fireInboundBufferUpdated();
if (!byteBuf.writable()) {
if (!byteBuf.isWritable()) {
throw new IllegalStateException(
"an inbound handler whose buffer is full must consume at " +
"least one byte.");
@ -130,7 +130,7 @@ public abstract class AbstractNioByteChannel extends AbstractNioChannel {
@Override
protected void doFlushByteBuffer(ByteBuf buf) throws Exception {
if (!buf.readable()) {
if (!buf.isReadable()) {
// Reset reader/writerIndex to 0 if the buffer is empty.
buf.clear();
return;
@ -141,7 +141,7 @@ public abstract class AbstractNioByteChannel extends AbstractNioChannel {
if (localFlushedAmount > 0) {
break;
}
if (!buf.readable()) {
if (!buf.isReadable()) {
// Reset reader/writerIndex to 0 if the buffer is empty.
buf.clear();
break;