byteBuf.getBytes(byteBuf.readerIndex(), out, byteBuf.readableBytes()); byteBuf.release(); };
@Override public final ByteBuf readerIndex(int readerIndex) { buf.readerIndex(readerIndex); return this; }
@Override public long skip(long bytes) throws IOException { int readable = buffer.readableBytes(); if (readable < bytes) { bytes = readable; } buffer.readerIndex((int) (buffer.readerIndex() + bytes)); return bytes; }
/** * * @param minus this value will be used as (currentPos - minus) to set * the current readerIndex in the buffer. */ void setReadPosition(int minus) { pos -= minus; readerIndex = getReadPosition(pos); buffer.readerIndex(readerIndex); }
@Override public int readableBytes() { if (terminated) { return buffer.readableBytes(); } else { return Integer.MAX_VALUE - buffer.readerIndex(); } }
public static ByteBuf encode(ByteBuf src, boolean breakLines, Base64Dialect dialect) { if (src == null) { throw new NullPointerException("src"); } ByteBuf dest = encode(src, src.readerIndex(), src.readableBytes(), breakLines, dialect); src.readerIndex(src.writerIndex()); return dest; }
public static ByteBuf decode(ByteBuf src, Base64Dialect dialect) { if (src == null) { throw new NullPointerException("src"); } ByteBuf dest = decode(src, src.readerIndex(), src.readableBytes(), dialect); src.readerIndex(src.writerIndex()); return dest; }
private int setInput(ByteBuf compressed) { int len = compressed.readableBytes(); if (compressed.hasArray()) { decompressor.setInput(compressed.array(), compressed.arrayOffset() + compressed.readerIndex(), len); } else { byte[] in = new byte[len]; compressed.getBytes(compressed.readerIndex(), in); decompressor.setInput(in, 0, in.length); } return len; }
private static int readLengthField(ByteBuf buffer) { int length = getSignedInt(buffer, buffer.readerIndex()); buffer.skipBytes(LENGTH_FIELD_SIZE); return length; }
@Override public int bytesBefore(int length, byte value) { final int readerIndex = buffer.readerIndex(); return bytesBefore(readerIndex, buffer.writerIndex() - readerIndex, value); }
/** * Returns a multi-line hexadecimal dump of the specified {@link ByteBuf} that is easy to read by humans. */ public static String prettyHexDump(ByteBuf buffer) { return prettyHexDump(buffer, buffer.readerIndex(), buffer.readableBytes()); }
/** * Computes the CRC32C checksum of the supplied data and performs the "mask" operation * on the computed checksum * * @param data The input data to calculate the CRC32C checksum of */ public static int calculateChecksum(ByteBuf data) { return calculateChecksum(data, data.readerIndex(), data.readableBytes()); }
/** * Returns a <a href="http://en.wikipedia.org/wiki/Hex_dump">hex dump</a> * of the specified buffer's readable bytes. */ public static String hexDump(ByteBuf buffer) { return hexDump(buffer, buffer.readerIndex(), buffer.readableBytes()); }
void setCurrentValue(ByteBuf value, int length) { this.currentValue = value; if (peekMode() == Mode.JSON_STRING_HASH_KEY) { //strip the quotes this.jsonPointer.addToken(this.currentValue.toString( this.currentValue.readerIndex() + 1, length - 1, Charset.defaultCharset())); } }
private static ByteBuf newDirectBuffer0(Object holder, ByteBuf buf, ByteBufAllocator alloc, int capacity) { final ByteBuf directBuf = alloc.directBuffer(capacity); directBuf.writeBytes(buf, buf.readerIndex(), capacity); ReferenceCountUtil.safeRelease(holder); return directBuf; }
private void decodeNonJdkCompatible(ChannelHandlerContext ctx, ByteBuf in) { try { in.skipBytes(unwrap(ctx, in, in.readerIndex(), in.readableBytes())); } catch (Throwable cause) { handleUnwrapThrowable(ctx, cause); } }
public ReadOnlyByteBuf(ByteBuf buffer) { super(buffer.maxCapacity()); if (buffer instanceof ReadOnlyByteBuf || buffer instanceof DuplicatedByteBuf) { this.buffer = buffer.unwrap(); } else { this.buffer = buffer; } setIndex(buffer.readerIndex(), buffer.writerIndex()); }
public ReadOnlyByteBuf(ByteBuf buffer) { super(buffer.maxCapacity()); if (buffer instanceof ReadOnlyByteBuf || buffer instanceof DuplicatedByteBuf) { this.buffer = buffer.unwrap(); } else { this.buffer = buffer; } setIndex(buffer.readerIndex(), buffer.writerIndex()); }
public DuplicatedByteBuf(ByteBuf buffer) { super(buffer.maxCapacity()); if (buffer instanceof DuplicatedByteBuf) { this.buffer = ((DuplicatedByteBuf) buffer).buffer; } else { this.buffer = buffer; } setIndex(buffer.readerIndex(), buffer.writerIndex()); markReaderIndex(); markWriterIndex(); }
public ByteBuf encodeDataFrame(ByteBufAllocator allocator, int streamId, boolean last, ByteBuf data) { byte flags = last ? SPDY_DATA_FLAG_FIN : 0; int length = data.readableBytes(); ByteBuf frame = allocator.ioBuffer(SPDY_HEADER_SIZE + length).order(ByteOrder.BIG_ENDIAN); frame.writeInt(streamId & 0x7FFFFFFF); frame.writeByte(flags); frame.writeMedium(length); frame.writeBytes(data, data.readerIndex(), length); return frame; }