private RPCProtos.RequestHeader getHeader(ByteBuf in, int headerSize) throws IOException { ByteBuf msg = in.readRetainedSlice(headerSize); try { byte[] array; int offset; int length = msg.readableBytes(); if (msg.hasArray()) { array = msg.array(); offset = msg.arrayOffset() + msg.readerIndex(); } else { array = new byte[length]; msg.getBytes(msg.readerIndex(), array, 0, length); offset = 0; } RPCProtos.RequestHeader.Builder builder = RPCProtos.RequestHeader.newBuilder(); ProtobufUtil.mergeFrom(builder, array, offset, length); return builder.build(); } finally { msg.release(); } }
@Override public boolean hasArray() { return buf.hasArray(); }
@Override public boolean hasArray() { return buf.hasArray(); }
@Override public boolean hasArray() { switch (components.size()) { case 0: return true; case 1: return components.get(0).buf.hasArray(); default: return false; } }
@Override public boolean hasArray() { return unwrap().hasArray(); }
@Override public boolean hasArray() { return unwrap().hasArray(); }
@Override public void update(ByteBuf b, int off, int len) { if (b.hasArray()) { update(b.array(), b.arrayOffset() + off, len); } else { try { method.invoke(checksum, CompressionUtil.safeNioBuffer(b)); } catch (Throwable cause) { throw new Error(); } } } }
private int setInput(ByteBuf decompressed) { int len = decompressed.readableBytes(); if (decompressed.hasArray()) { compressor.setInput(decompressed.array(), decompressed.arrayOffset() + decompressed.readerIndex(), len); } else { byte[] in = new byte[len]; decompressed.getBytes(decompressed.readerIndex(), in); compressor.setInput(in, 0, in.length); } return len; }
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; }
/** * @param buffer buffer with a backing byte array */ SeekAheadOptimize(ByteBuf buffer) { if (!buffer.hasArray()) { throw new IllegalArgumentException("buffer hasn't backing byte array"); } this.buffer = buffer; bytes = buffer.array(); readerIndex = buffer.readerIndex(); origPos = pos = buffer.arrayOffset() + readerIndex; limit = buffer.arrayOffset() + buffer.writerIndex(); }
/** * @see #update(byte[], int, int) */ public void update(ByteBuf b, int off, int len) { if (b.hasArray()) { update(b.array(), b.arrayOffset() + off, len); } else { b.forEachByte(off, len, updateProcessor); } }
@Override public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) { checkDstIndex(index, length, dstIndex, dst.capacity()); if (dst.hasArray()) { getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length); } else if (dst.nioBufferCount() > 0) { for (ByteBuffer bb: dst.nioBuffers(dstIndex, length)) { int bbLen = bb.remaining(); getBytes(index, bb); index += bbLen; } } else { dst.setBytes(dstIndex, this, index, length); } return this; }
@Override public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) { checkDstIndex(index, length, dstIndex, dst.capacity()); if (dst.hasArray()) { getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length); } else if (dst.nioBufferCount() > 0) { for (ByteBuffer bb: dst.nioBuffers(dstIndex, length)) { int bbLen = bb.remaining(); getBytes(index, bb); index += bbLen; } } else { dst.setBytes(dstIndex, this, index, length); } return this; }
@Override public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) { checkDstIndex(index, length, dstIndex, dst.capacity()); if (dst.hasArray()) { getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length); } else if (dst.nioBufferCount() > 0) { for (ByteBuffer bb: dst.nioBuffers(dstIndex, length)) { int bbLen = bb.remaining(); getBytes(index, bb); index += bbLen; } } else { dst.setBytes(dstIndex, this, index, length); } return this; }
static void getBytes(AbstractByteBuf buf, long addr, int index, ByteBuf dst, int dstIndex, int length) { buf.checkIndex(index, length); checkNotNull(dst, "dst"); if (isOutOfBounds(dstIndex, length, dst.capacity())) { throw new IndexOutOfBoundsException("dstIndex: " + dstIndex); } if (dst.hasMemoryAddress()) { PlatformDependent.copyMemory(addr, dst.memoryAddress() + dstIndex, length); } else if (dst.hasArray()) { PlatformDependent.copyMemory(addr, dst.array(), dst.arrayOffset() + dstIndex, length); } else { dst.setBytes(dstIndex, buf, index, length); } }
static void setBytes(AbstractByteBuf buf, long addr, int index, ByteBuf src, int srcIndex, int length) { buf.checkIndex(index, length); checkNotNull(src, "src"); if (isOutOfBounds(srcIndex, length, src.capacity())) { throw new IndexOutOfBoundsException("srcIndex: " + srcIndex); } if (length != 0) { if (src.hasMemoryAddress()) { PlatformDependent.copyMemory(src.memoryAddress() + srcIndex, addr, length); } else if (src.hasArray()) { PlatformDependent.copyMemory(src.array(), src.arrayOffset() + srcIndex, addr, length); } else { src.getBytes(srcIndex, buf, index, length); } } }
@Override public ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) { checkDstIndex(index, length, dstIndex, dst.capacity()); if (dst.hasMemoryAddress()) { PlatformDependent.copyMemory(array, index, dst.memoryAddress() + dstIndex, length); } else if (dst.hasArray()) { getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length); } else { dst.setBytes(dstIndex, array, index, length); } return this; }
@Override public ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) { checkSrcIndex(index, length, srcIndex, src.capacity()); if (src.hasMemoryAddress()) { PlatformDependent.copyMemory(src.memoryAddress() + srcIndex, array, index, length); } else if (src.hasArray()) { setBytes(index, src.array(), src.arrayOffset() + srcIndex, length); } else { src.getBytes(srcIndex, array, index, length); } return this; }
@Override public final ByteBuf setBytes(int index, ByteBuf src, int srcIndex, int length) { checkSrcIndex(index, length, srcIndex, src.capacity()); if (src.hasMemoryAddress()) { PlatformDependent.copyMemory(src.memoryAddress() + srcIndex, memory, idx(index), length); } else if (src.hasArray()) { setBytes(index, src.array(), src.arrayOffset() + srcIndex, length); } else { src.getBytes(srcIndex, memory, idx(index), length); } return this; }
@Override public final ByteBuf getBytes(int index, ByteBuf dst, int dstIndex, int length) { checkDstIndex(index, length, dstIndex, dst.capacity()); if (dst.hasMemoryAddress()) { PlatformDependent.copyMemory(memory, idx(index), dst.memoryAddress() + dstIndex, length); } else if (dst.hasArray()) { getBytes(index, dst.array(), dst.arrayOffset() + dstIndex, length); } else { dst.setBytes(dstIndex, memory, idx(index), length); } return this; }