Refine search
public long skip(long bytes) throws IOException { int readable = buffer.readableBytes(); if (readable < bytes) { bytes = readable; } buffer.readerIndex((int) (buffer.readerIndex() + bytes)); return bytes; }
public void writeBytes(ChannelBuffer src, int length) { if (length > src.readableBytes()) { throw new IndexOutOfBoundsException("Too many bytes to write - Need " + length + ", maximum is " + src.readableBytes()); } writeBytes(src, src.readerIndex(), length); src.readerIndex(src.readerIndex() + length); }
public void setBytes(int index, ChannelBuffer src, int length) { if (length > src.readableBytes()) { throw new IndexOutOfBoundsException("Too many bytes to write: Need " + length + ", maximum is " + src.readableBytes()); } setBytes(index, src, src.readerIndex(), length); src.readerIndex(src.readerIndex() + length); }
public byte[] get() { if (channelBuffer == null) { return new byte[0]; } byte[] array = new byte[channelBuffer.readableBytes()]; channelBuffer.getBytes(channelBuffer.readerIndex(), array); return array; }
@Override protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception { if (!(msg instanceof ChannelBuffer)) { return msg; } ChannelBuffer src = (ChannelBuffer) msg; return Base64.encode( src, src.readerIndex(), src.readableBytes(), breakLines, dialect); } }
/** * 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(ChannelBuffer buffer) { return hexDump(buffer, buffer.readerIndex(), buffer.readableBytes()); }
public static ChannelBuffer decode(ChannelBuffer src, Base64Dialect dialect, ChannelBufferFactory bufferFactory) { if (src == null) { throw new NullPointerException("src"); } ChannelBuffer dest = decode(src, src.readerIndex(), src.readableBytes(), dialect, bufferFactory); src.readerIndex(src.writerIndex()); return dest; }
public static ChannelBuffer encode( ChannelBuffer src, boolean breakLines, Base64Dialect dialect, ChannelBufferFactory bufferFactory) { if (src == null) { throw new NullPointerException("src"); } ChannelBuffer dest = encode( src, src.readerIndex(), src.readableBytes(), breakLines, dialect, bufferFactory); src.readerIndex(src.writerIndex()); return dest; }
private int setInput(ChannelBuffer 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(ChannelBuffer 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; }
@Override protected Object decode( ChannelHandlerContext ctx, Channel channel, ChannelBuffer buffer) throws Exception { if (buffer.readableBytes() < frameLength) { return null; } else { ChannelBuffer frame = extractFrame(buffer, buffer.readerIndex(), frameLength); buffer.skipBytes(frameLength); return frame; } }
@Override protected Object decode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception { if (msg instanceof String) { msg = ChannelBuffers.copiedBuffer((String) msg, CharsetUtil.US_ASCII); } else if (!(msg instanceof ChannelBuffer)) { return msg; } ChannelBuffer src = (ChannelBuffer) msg; return Base64.decode( src, src.readerIndex(), src.readableBytes(), dialect); }
public int readableBytes() { if (terminated) { return buf().readableBytes(); } else { return Integer.MAX_VALUE - buf().readerIndex(); } }
/** * Creates a new instance. * * @param maxFrameLength the maximum length of the decoded frame. * A {@link TooLongFrameException} is thrown if * the length of the frame exceeds this value. * @param stripDelimiter whether the decoded frame should strip out the * delimiter or not * @param failFast If <tt>true</tt>, a {@link TooLongFrameException} is * thrown as soon as the decoder notices the length of the * frame will exceed <tt>maxFrameLength</tt> regardless of * whether the entire frame has been read. * If <tt>false</tt>, a {@link TooLongFrameException} is * thrown after the entire frame that exceeds * <tt>maxFrameLength</tt> has been read. * @param delimiter the delimiter */ public DelimiterBasedFrameDecoder( int maxFrameLength, boolean stripDelimiter, boolean failFast, ChannelBuffer delimiter) { this(maxFrameLength, stripDelimiter, failFast, new ChannelBuffer[] { delimiter.slice( delimiter.readerIndex(), delimiter.readableBytes()) }); }
/** * Creates a new stream which reads data from the specified {@code buffer} * starting at the current {@code readerIndex} and ending at * {@code readerIndex + length}. * * @throws IndexOutOfBoundsException * if {@code readerIndex + length} is greater than * {@code writerIndex} */ public ChannelBufferInputStream(ChannelBuffer buffer, int length) { if (buffer == null) { throw new NullPointerException("buffer"); } if (length < 0) { throw new IllegalArgumentException("length: " + length); } if (length > buffer.readableBytes()) { throw new IndexOutOfBoundsException("Too many bytes to be read - Needs " + length + ", maximum is " + buffer.readableBytes()); } this.buffer = buffer; startIndex = buffer.readerIndex(); endIndex = startIndex + length; buffer.markReaderIndex(); }
public void setContent(ChannelBuffer buffer) throws IOException { if (buffer == null) { throw new NullPointerException("buffer"); } size = buffer.readableBytes(); checkSize(size); if (definedSize > 0 && definedSize < size) { throw new IOException("Out of size: " + size + " > " + definedSize); } if (file == null) { file = tempFile(); } if (buffer.readableBytes() == 0) { // empty file file.createNewFile(); return; } FileOutputStream outputStream = new FileOutputStream(file); FileChannel localfileChannel = outputStream.getChannel(); ByteBuffer byteBuffer = buffer.toByteBuffer(); int written = 0; while (written < size) { written += localfileChannel.write(byteBuffer); } buffer.readerIndex(buffer.readerIndex() + written); localfileChannel.force(false); localfileChannel.close(); outputStream.close(); completed = true; }
/** * * @return the next ChannelBuffer to send as a HttpChunk and modifying currentBuffer * accordingly */ private ChannelBuffer fillChannelBuffer() { int length = currentBuffer.readableBytes(); if (length > HttpPostBodyUtil.chunkSize) { ChannelBuffer slice = currentBuffer.slice(currentBuffer.readerIndex(), HttpPostBodyUtil.chunkSize); currentBuffer.skipBytes(HttpPostBodyUtil.chunkSize); return slice; } else { // to continue ChannelBuffer slice = currentBuffer; currentBuffer = null; return slice; } }
public void addContent(ChannelBuffer buffer, boolean last) throws IOException { if (buffer != null) { int localsize = buffer.readableBytes(); checkSize(size + localsize); if (definedSize > 0 && definedSize < size + localsize) { buffer.readerIndex(buffer.readerIndex() + written);
private static String formatBuffer(ChannelBuffer buf) { int length = buf.readableBytes(); int rows = length / 16 + (length % 15 == 0? 0 : 1) + 4; StringBuilder dump = new StringBuilder(rows * 80); NEWLINE + "+--------+-------------------------------------------------+----------------+"); final int startIndex = buf.readerIndex(); final int endIndex = buf.writerIndex();
/** * Performs an SHA-1 hash * * @param buffer * buffer to hash * @return Hashed data */ static ChannelBuffer sha1(ChannelBuffer buffer) { try { MessageDigest md = MessageDigest.getInstance("SHA1"); if (buffer.hasArray()) { int offset = buffer.arrayOffset() + buffer.readerIndex(); int length = buffer.readableBytes(); md.update(buffer.array(), offset, length); } else { md.update(buffer.toByteBuffer()); } return ChannelBuffers.wrappedBuffer(md.digest()); } catch (NoSuchAlgorithmException e) { throw new InternalError("SHA-1 not supported on this platform"); } }