Examples of org.jboss.netty.buffer.ChannelBuffer

org.jboss.netty.buffer.ChannelBuffer
kipedia.org/wiki/Index_(information_technology)#Array_element_identifier">zero-based indexing. It means the index of the first byte is always {@code 0} and the index ofthe last byte is always {@link #capacity() capacity - 1}. For example, to iterate all bytes of a buffer, you can do the following, regardless of its internal implementation:
```
 ChannelBuffer buffer = ...; for (int i = 0; i < buffer.capacity(); i ++) { byte b = array.getByte(i); System.out.println((char) b); } 
```
Sequential Access Indexing
{@link ChannelBuffer} provides two pointer variables to support sequentialread and write operations - {@link #readerIndex() readerIndex} for a readoperation and {@link #writerIndex() writerIndex} for a write operationrespectively. The following diagram shows how a buffer is segmented into three areas by the two pointers:
```
 +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | |                   |     (CONTENT)    |                  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity 
```
Readable bytes (the actual content)
This segment is where the actual data is stored. Any operation whose name starts with {@code read} or {@code skip} will get or skip the data at thecurrent {@link #readerIndex() readerIndex} and increase it by the number ofread bytes. If the argument of the read operation is also a {@link ChannelBuffer} and no start index is specified, the specifiedbuffer's {@link #readerIndex() readerIndex} is increased together.
If there's not enough content left, {@link IndexOutOfBoundsException} israised. The default value of newly allocated, wrapped or copied buffer's {@link #readerIndex() readerIndex} is {@code 0}.
```
 // Iterates the readable bytes of a buffer. ChannelBuffer buffer = ...; while (buffer.readable()) { System.out.println(buffer.readByte()); } 
```
Writable bytes
This segment is a undefined space which needs to be filled. Any operation whose name ends with {@code write} will write the data at the current{@link #writerIndex() writerIndex} and increase it by the number of writtenbytes. If the argument of the write operation is also a {@link ChannelBuffer}, and no start index is specified, the specified buffer's {@link #readerIndex() readerIndex} is increased together.
If there's not enough writable bytes left, {@link IndexOutOfBoundsException}is raised. The default value of newly allocated buffer's {@link #writerIndex() writerIndex} is {@code 0}. The default value of wrapped or copied buffer's {@link #writerIndex() writerIndex} is the{@link #capacity() capacity} of the buffer.
```
 // Fills the writable bytes of a buffer with random integers. ChannelBuffer buffer = ...; while (buffer.writableBytes() >= 4) { buffer.writeInt(random.nextInt()); } 
```
Discardable bytes
This segment contains the bytes which were read already by a read operation. Initially, the size of this segment is {@code 0}, but its size increases up to the {@link #writerIndex() writerIndex} as read operations are executed.The read bytes can be discarded by calling {@link #discardReadBytes()} toreclaim unused area as depicted by the following diagram:
```
 BEFORE discardReadBytes() +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity AFTER discardReadBytes() +------------------+--------------------------------------+ |  readable bytes  |    writable bytes (got more space)   | +------------------+--------------------------------------+ |                  |                                      | readerIndex (0) <= writerIndex (decreased)        <=        capacity 
```
Clearing the buffer indexes
You can set both {@link #readerIndex() readerIndex} and{@link #writerIndex() writerIndex} to {@code 0} by calling {@link #clear()}. It does not clear the buffer content (e.g. filling with {@code 0}) but just clears the two pointers. Please also note that the semantic of this operation is different from {@link ByteBuffer#clear()}.
```
 BEFORE clear() +-------------------+------------------+------------------+ | discardable bytes |  readable bytes  |  writable bytes  | +-------------------+------------------+------------------+ |                   |                  |                  | 0      <=      readerIndex   <=   writerIndex    <=    capacity AFTER clear() +---------------------------------------------------------+ |             writable bytes (got more space)             | +---------------------------------------------------------+ |                                                         | 0 = readerIndex = writerIndex            <=            capacity 
```
Search operations
Various {@code indexOf()} methods help you locate an index of a value whichmeets a certain criteria. Complicated dynamic sequential search can be done with {@link ChannelBufferIndexFinder} as well as simple static single bytesearch.
Mark and reset
There are two marker indexes in every buffer. One is for storing {@link #readerIndex() readerIndex} and the other is for storing{@link #writerIndex() writerIndex}. You can always reposition one of the two indexes by calling a reset method. It works in a similar fashion to the mark and reset methods in {@link InputStream} except that there's no{@code readlimit}.
Derived buffers
You can create a view of an existing buffer by calling either {@link #duplicate()}, {@link #slice()} or {@link #slice(int,int)}. A derived buffer will have an independent {@link #readerIndex() readerIndex}, {@link #writerIndex() writerIndex} and marker indexes, while it sharesother internal data representation, just like a NIO buffer does.
In case a completely fresh copy of an existing buffer is required, please call {@link #copy()} method instead.
Conversion to existing JDK types

NIO Buffers
Various {@link #toByteBuffer()} and {@link #toByteBuffers()} methods converta {@link ChannelBuffer} into one or more NIO buffers. These methods avoidbuffer allocation and memory copy whenever possible, but there's no guarantee that memory copy will not be involved or that an explicit memory copy will be involved.
Strings
Various {@link #toString(String)} methods convert a {@link ChannelBuffer}into a {@link String}. Plesae note that {@link #toString()} is not aconversion method.
I/O Streams
Please refer to {@link ChannelBufferInputStream} and{@link ChannelBufferOutputStream}. @author The Netty Project (netty-dev@lists.jboss.org) @author Trustin Lee (tlee@redhat.com) @version $Rev: 1017 $, $Date: 2009-03-12 15:40:36 +0900 (Thu, 12 Mar 2009) $ @apiviz.landmark

        oout.writeObject(e.getMessage());
        ExternalizeUtil.writeCollection(oout, oout.getReferences());
        oout.flush();
        oout.close();


        ChannelBuffer encoded = bout.buffer();
        encoded.setInt(0, encoded.writerIndex() - 4);
        write(ctx, e.getFuture(), encoded, e.getRemoteAddress());
    for (InputStream is : oout.getStreams()) {
      Channels.write(ctx.getChannel(), new AnonymousChunkedStream(new BufferedInputStream(is, CHUNK_SIZE)));
    }
    }

View Full Code Here

      super(in, CHUNK_SIZE);
    }
      
    @Override
    public Object nextChunk() throws Exception {
      ChannelBuffer cb = (ChannelBuffer)super.nextChunk();
      int length = cb.capacity();
      ChannelBuffer prefix = wrappedBuffer(new byte[2]);
      prefix.setShort(0, (short)length);
      if (!hasNextChunk()) {
        //append a 0 short
        return wrappedBuffer(prefix, cb, wrappedBuffer(new byte[2]));
      }

View Full Code Here

    sb.append('"');
  }  
  
  @Override
  public void sslDenied() {
    ChannelBuffer buffer = ChannelBuffers.directBuffer(1);
    buffer.writeByte('N');
    Channels.write(this.ctx, this.message.getFuture(), buffer, this.message.getRemoteAddress());    
  }

View Full Code Here

    int len = buff.length;
    this.outBuffer = null;
    this.dataOut = null;
    
    // now build the wire contents.
    ChannelBuffer buffer = ChannelBuffers.directBuffer(len+5);
    buffer.writeByte((byte)this.messageType);
    buffer.writeInt(len+4);
    buffer.writeBytes(buff);
    Channels.write(this.ctx, this.message.getFuture(), buffer, this.message.getRemoteAddress());
  }

View Full Code Here

        String key1 = req.getHeader(SEC_WEBSOCKET_KEY1);
        String key2 = req.getHeader(SEC_WEBSOCKET_KEY2);
        int a = (int) (Long.parseLong(key1.replaceAll("[^0-9]", "")) / key1.replaceAll("[^ ]", "").length());
        int b = (int) (Long.parseLong(key2.replaceAll("[^0-9]", "")) / key2.replaceAll("[^ ]", "").length());
        long c = req.getContent().readLong();
        ChannelBuffer input = ChannelBuffers.buffer(16);
        input.writeInt(a);
        input.writeInt(b);
        input.writeLong(c);
        try {
            ChannelBuffer output = ChannelBuffers.wrappedBuffer(
                    MessageDigest.getInstance("MD5").digest(input.array()));
            res.setContent(output);
        } catch (NoSuchAlgorithmException e) {
            throw new RuntimeException(e);
        }

View Full Code Here

            case MASKING_KEY:
                maskingKey = buffer.readBytes(4);
                checkpoint(State.PAYLOAD);
            case PAYLOAD:
                checkpoint(State.FRAME_START);
                ChannelBuffer frame = buffer.readBytes(currentFrameLength);
                unmask(frame);


                if (this.opcode == OPCODE_CONT) {
                    this.opcode = fragmentOpcode;
                    frames.add(frame);


                    frame = channel.getConfig().getBufferFactory().getBuffer(0);
                    for (ChannelBuffer channelBuffer : frames) {
                        frame.ensureWritableBytes(channelBuffer.readableBytes());
                        frame.writeBytes(channelBuffer);
                    }


                    this.fragmentOpcode = null;
                    frames.clear();
                }


                if (this.opcode == OPCODE_TEXT) {
                    if (frame.readableBytes() > MAX_LENGTH) {
                        throw new TooLongFrameException();
                    }
                    return new DefaultWebSocketFrame(0x00, frame);
                } else if (this.opcode == OPCODE_BINARY) {
                    return new DefaultWebSocketFrame(0xFF, frame);

View Full Code Here


    @Override
    protected Object encode(ChannelHandlerContext ctx, Channel channel, Object msg) throws Exception {
        if (msg instanceof WebSocketFrame) {
            WebSocketFrame frame = (WebSocketFrame) msg;
            ChannelBuffer data = frame.getBinaryData();
            ChannelBuffer encoded =
                    channel.getConfig().getBufferFactory().getBuffer(
                            data.order(), data.readableBytes() + 6);


            byte opcode;
            if(frame instanceof Ping) {
                opcode = OPCODE_PING;
            } else if(frame instanceof Pong) {
                opcode = OPCODE_PONG;
            } else {
                opcode = frame.isText() ? OPCODE_TEXT : OPCODE_BINARY;
            }
            encoded.writeByte(0x80 | opcode);


            int length = data.readableBytes();
            if (length < 126) {
                encoded.writeByte(length);
            } else if (length < 65535) {
                encoded.writeByte(126);
                encoded.writeShort(length);
            } else {
                encoded.writeByte(127);
                encoded.writeInt(length);
            }


            encoded.writeBytes(data, data.readerIndex(), data.readableBytes());
            encoded = encoded.slice(0, encoded.writerIndex());
            return encoded;
        }
        return msg;
    }

View Full Code Here


    @Override
    public void writeRequested(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        Command cmd = (Command) e.getMessage();
        Channel channel = ctx.getChannel();
        ChannelBuffer buf = ChannelBuffers.dynamicBuffer(channel.getConfig().getBufferFactory());
        cmd.encode(buf);
        Channels.write(ctx, e.getFuture(), buf);
    }

View Full Code Here

        Channels.write(ctx, e.getFuture(), buf);
    }


    @Override
    public void messageReceived(ChannelHandlerContext ctx, MessageEvent e) throws Exception {
        ChannelBuffer input = (ChannelBuffer) e.getMessage();
        if (!input.readable()) return;


        buffer.discardReadBytes();
        buffer.writeBytes(input);


        decode(ctx, buffer);

View Full Code Here

            }


            if (request.isChunked()) {
                readingChunks = true;
            } else {
                ChannelBuffer content = request.getContent();
                if (content.readable()) {
                    buf.append("CONTENT: " + content.toString(CharsetUtil.UTF_8) + "\r\n");
                }
                writeResponse(e);
            }
        } else {
            HttpChunk chunk = (HttpChunk) e.getMessage();

View Full Code Here

0 1 2 3 4 5 6 7 8 9

TOP

Related Classes of org.jboss.netty.buffer.ChannelBuffer

ch.mimo.netty.handler.codec.icap.DataMockery

ch.mimo.netty.handler.codec.icap.EncapsulatedTest

ch.mimo.netty.handler.codec.icap.IcapChunkAggregator

ch.mimo.netty.handler.codec.icap.IcapChunkAggregatorTest

ch.mimo.netty.handler.codec.icap.IcapChunkSeparator

ch.mimo.netty.handler.codec.icap.IcapDecoderUtilTest

ch.mimo.netty.handler.codec.icap.IcapMessageEncoder

ch.mimo.netty.handler.codec.icap.IcapRequestEncoderPipelineTest

co.cask.cdap.gateway.handlers.util.AbstractAppFabricHttpHandler

co.cask.cdap.internal.app.runtime.procedure.HttpProcedureResponder

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of org.jboss.netty.buffer.ChannelBuffer

Sequential Access Indexing

Readable bytes (the actual content)

Writable bytes

Discardable bytes

Clearing the buffer indexes

Search operations

Mark and reset

Derived buffers

Conversion to existing JDK types

NIO Buffers

Strings

I/O Streams

Related Classes of org.jboss.netty.buffer.ChannelBuffer