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 int arrayOffset() { return buf.arrayOffset(); }
@Override public int arrayOffset() { return buf.arrayOffset(); }
@Override public int arrayOffset() { switch (components.size()) { case 0: return 0; case 1: return components.get(0).buf.arrayOffset(); default: throw new UnsupportedOperationException(); } }
@Override public int arrayOffset() { return unwrap().arrayOffset(); }
/** * @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(); }
@Override public int arrayOffset() { return idx(unwrap().arrayOffset()); }
@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 void deflate(ByteBuf out) { int numBytes; do { int writerIndex = out.writerIndex(); numBytes = deflater.deflate( out.array(), out.arrayOffset() + writerIndex, out.writableBytes(), Deflater.SYNC_FLUSH); out.writerIndex(writerIndex + numBytes); } while (numBytes > 0); }
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; }
private boolean compressInto(ByteBuf compressed) { byte[] out = compressed.array(); int off = compressed.arrayOffset() + compressed.writerIndex(); int toWrite = compressed.writableBytes(); int numBytes = compressor.deflate(out, off, toWrite, Deflater.SYNC_FLUSH); compressed.writerIndex(compressed.writerIndex() + numBytes); return numBytes == toWrite; }
/** * @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); } }
static void getBytes(AbstractByteBuf buf, long addr, int index, OutputStream out, int length) throws IOException { buf.checkIndex(index, length); if (length != 0) { ByteBuf tmpBuf = buf.alloc().heapBuffer(length); try { byte[] tmp = tmpBuf.array(); int offset = tmpBuf.arrayOffset(); PlatformDependent.copyMemory(addr, tmp, offset, length); out.write(tmp, offset, length); } finally { tmpBuf.release(); } } }
@Override protected void encode( ChannelHandlerContext ctx, MessageNano msg, List<Object> out) throws Exception { final int size = msg.getSerializedSize(); final ByteBuf buffer = ctx.alloc().heapBuffer(size, size); final byte[] array = buffer.array(); CodedOutputByteBufferNano cobbn = CodedOutputByteBufferNano.newInstance(array, buffer.arrayOffset(), buffer.capacity()); msg.writeTo(cobbn); buffer.writerIndex(size); out.add(buffer); } }
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); } }
@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; }