org.jboss.netty.buffer

## Interface ChannelBuffer

- All Superinterfaces:
    Comparable<ChannelBuffer>
  All Known Subinterfaces:
    WrappedChannelBuffer
  All Known Implementing Classes:
    AbstractChannelBuffer, BigEndianHeapChannelBuffer, ByteBufferBackedChannelBuffer, CompositeChannelBuffer, DuplicatedChannelBuffer, DynamicChannelBuffer, HeapChannelBuffer, LittleEndianHeapChannelBuffer, ReadOnlyChannelBuffer, SlicedChannelBuffer, TruncatedChannelBuffer

      public interface ChannelBuffer
      extends Comparable<ChannelBuffer>

  A random and sequential accessible sequence of zero or more bytes (octets). This interface provides an abstract view for one or more primitive byte arrays (`byte[]`) and NIO buffers.

  ### Creation of a buffer

  It is recommended to create a new buffer using the helper methods in `ChannelBuffers` rather than calling an individual implementation's constructor.

  ### Random Access Indexing

  Just like an ordinary primitive byte array, `ChannelBuffer` uses zero-based indexing. It means the index of the first byte is always `0` and the index of the last byte is always `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 = buffer.getByte(i);
           System.out.println((char) b);
       }

  ### Sequential Access Indexing

  `ChannelBuffer` provides two pointer variables to support sequential read and write operations - `readerIndex` for a read operation and `writerIndex` for a write operation respectively. 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 `read` or `skip` will get or skip the data at the current `readerIndex` and increase it by the number of read bytes. If the argument of the read operation is also a `ChannelBuffer` and no destination index is specified, the specified buffer's `readerIndex` is increased together.

  If there's not enough content left, `IndexOutOfBoundsException` is raised. The default value of newly allocated, wrapped or copied buffer's `readerIndex` is `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 `write` will write the data at the current `writerIndex` and increase it by the number of written bytes. If the argument of the write operation is also a `ChannelBuffer`, and no source index is specified, the specified buffer's `readerIndex` is increased together.

  If there's not enough writable bytes left, `IndexOutOfBoundsException` is raised. The default value of newly allocated buffer's `writerIndex` is `0`. The default value of wrapped or copied buffer's `writerIndex` is the `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 `0`, but its size increases up to the `writerIndex` as read operations are executed. The read bytes can be discarded by calling `discardReadBytes()` to reclaim 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

  Please note that there is no guarantee about the content of writable bytes after calling `discardReadBytes()`. The writable bytes will not be moved in most cases and could even be filled with completely different data depending on the underlying buffer implementation.

  #### Clearing the buffer indexes

  You can set both `readerIndex` and `writerIndex` to `0` by calling `clear()`. It does not clear the buffer content (e.g. filling with `0`) but just clears the two pointers. Please also note that the semantic of this operation is different from `Buffer.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 `indexOf(int, int, byte)` methods help you locate an index of a value which meets a certain criteria. Complicated dynamic sequential search can be done with `ChannelBufferIndexFinder` as well as simple static single byte search.

  If you are decoding variable length data such as NUL-terminated string, you will find `bytesBefore(byte)` also useful.

  ### Mark and reset

  There are two marker indexes in every buffer. One is for storing `readerIndex` and the other is for storing `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 `InputStream` except that there's no `readlimit`.

  ### Derived buffers

  You can create a view of an existing buffer by calling either `duplicate()`, `slice()` or `slice(int, int)`. A derived buffer will have an independent `readerIndex`, `writerIndex` and marker indexes, while it shares other internal data representation, just like a NIO buffer does.

  In case a completely fresh copy of an existing buffer is required, please call `copy()` method instead.

  ### Conversion to existing JDK types

  #### Byte array

  If a `ChannelBuffer` is backed by a byte array (i.e. `byte[]`), you can access it directly via the `array()` method. To determine if a buffer is backed by a byte array, `hasArray()` should be used.

  #### NIO Buffers

  Various `toByteBuffer()` and `toByteBuffers()` methods convert a `ChannelBuffer` into one or more NIO buffers. These methods avoid buffer allocation and memory copy whenever possible, but there's no guarantee that memory copy will not be involved.

  #### Strings

  Various `toString(String)` methods convert a `ChannelBuffer` into a `String`. Please note that `toString()` is not a conversion method.

  #### I/O Streams

  Please refer to `ChannelBufferInputStream` and `ChannelBufferOutputStream`.

- - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `byte[]` | `array()` Returns the backing byte array of this buffer.
    `int` | `arrayOffset()` Returns the offset of the first byte within the backing byte array of this buffer.
    `int` | `bytesBefore(byte value)` Locates the first occurrence of the specified `value` in this buffer.
    `int` | `bytesBefore(ChannelBufferIndexFinder indexFinder)` Locates the first place where the specified `indexFinder` returns `true`.
    `int` | `bytesBefore(int length, byte value)` Locates the first occurrence of the specified `value` in this buffer.
    `int` | `bytesBefore(int length, ChannelBufferIndexFinder indexFinder)` Locates the first place where the specified `indexFinder` returns `true`.
    `int` | `bytesBefore(int index, int length, byte value)` Locates the first occurrence of the specified `value` in this buffer.
    `int` | `bytesBefore(int index, int length, ChannelBufferIndexFinder indexFinder)` Locates the first place where the specified `indexFinder` returns `true`.
    `int` | `capacity()` Returns the number of bytes (octets) this buffer can contain.
    `void` | `clear()` Sets the `readerIndex` and `writerIndex` of this buffer to `0`.
    `int` | `compareTo(ChannelBuffer buffer)` Compares the content of the specified buffer to the content of this buffer.
    `ChannelBuffer` | `copy()` Returns a copy of this buffer's readable bytes.
    `ChannelBuffer` | `copy(int index, int length)` Returns a copy of this buffer's sub-region.
    `void` | `discardReadBytes()` Discards the bytes between the 0th index and `readerIndex`.
    `ChannelBuffer` | `duplicate()` Returns a buffer which shares the whole region of this buffer.
    `void` | `ensureWritableBytes(int writableBytes)` Makes sure the number of the writable bytes is equal to or greater than the specified value.
    `boolean` | `equals(Object obj)` Determines if the content of the specified buffer is identical to the content of this array.
    `ChannelBufferFactory` | `factory()` Returns the factory which creates a `ChannelBuffer` whose type and default `ByteOrder` are same with this buffer.
    `byte` | `getByte(int index)` Gets a byte at the specified absolute `index` in this buffer.
    `void` | `getBytes(int index, byte[] dst)` Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
    `void` | `getBytes(int index, byte[] dst, int dstIndex, int length)` Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
    `void` | `getBytes(int index, ByteBuffer dst)` Transfers this buffer's data to the specified destination starting at the specified absolute `index` until the destination's position reaches its limit.
    `void` | `getBytes(int index, ChannelBuffer dst)` Transfers this buffer's data to the specified destination starting at the specified absolute `index` until the destination becomes non-writable.
    `void` | `getBytes(int index, ChannelBuffer dst, int length)` Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
    `void` | `getBytes(int index, ChannelBuffer dst, int dstIndex, int length)` Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
    `int` | `getBytes(int index, GatheringByteChannel out, int length)` Transfers this buffer's data to the specified channel starting at the specified absolute `index`.
    `void` | `getBytes(int index, OutputStream out, int length)` Transfers this buffer's data to the specified stream starting at the specified absolute `index`.
    `char` | `getChar(int index)` Gets a 2-byte UTF-16 character at the specified absolute `index` in this buffer.
    `double` | `getDouble(int index)` Gets a 64-bit floating point number at the specified absolute `index` in this buffer.
    `float` | `getFloat(int index)` Gets a 32-bit floating point number at the specified absolute `index` in this buffer.
    `int` | `getInt(int index)` Gets a 32-bit integer at the specified absolute `index` in this buffer.
    `long` | `getLong(int index)` Gets a 64-bit long integer at the specified absolute `index` in this buffer.
    `int` | `getMedium(int index)` Gets a 24-bit medium integer at the specified absolute `index` in this buffer.
    `short` | `getShort(int index)` Gets a 16-bit short integer at the specified absolute `index` in this buffer.
    `short` | `getUnsignedByte(int index)` Gets an unsigned byte at the specified absolute `index` in this buffer.
    `long` | `getUnsignedInt(int index)` Gets an unsigned 32-bit integer at the specified absolute `index` in this buffer.
    `int` | `getUnsignedMedium(int index)` Gets an unsigned 24-bit medium integer at the specified absolute `index` in this buffer.
    `int` | `getUnsignedShort(int index)` Gets an unsigned 16-bit short integer at the specified absolute `index` in this buffer.
    `boolean` | `hasArray()` Returns `true` if and only if this buffer has a backing byte array.
    `int` | `hashCode()` Returns a hash code which was calculated from the content of this buffer.
    `int` | `indexOf(int fromIndex, int toIndex, byte value)` Locates the first occurrence of the specified `value` in this buffer.
    `int` | `indexOf(int fromIndex, int toIndex, ChannelBufferIndexFinder indexFinder)` Locates the first place where the specified `indexFinder` returns `true`.
    `boolean` | `isDirect()` Returns `true` if and only if this buffer is backed by an NIO direct buffer.
    `void` | `markReaderIndex()` Marks the current `readerIndex` in this buffer.
    `void` | `markWriterIndex()` Marks the current `writerIndex` in this buffer.
    `ByteOrder` | `order()` Returns the endianness of this buffer.
    `boolean` | `readable()` Returns `true` if and only if `(this.writerIndex - this.readerIndex)` is greater than `0`.
    `int` | `readableBytes()` Returns the number of readable bytes which is equal to `(this.writerIndex - this.readerIndex)`.
    `byte` | `readByte()` Gets a byte at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
    `void` | `readBytes(byte[] dst)` Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `dst.length`).
    `void` | `readBytes(byte[] dst, int dstIndex, int length)` Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
    `void` | `readBytes(ByteBuffer dst)` Transfers this buffer's data to the specified destination starting at the current `readerIndex` until the destination's position reaches its limit, and increases the `readerIndex` by the number of the transferred bytes.
    `void` | `readBytes(ChannelBuffer dst)` Transfers this buffer's data to the specified destination starting at the current `readerIndex` until the destination becomes non-writable, and increases the `readerIndex` by the number of the transferred bytes.
    `ChannelBuffer` | `readBytes(ChannelBufferIndexFinder indexFinder)` Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `readBytes(int)` instead.
    `void` | `readBytes(ChannelBuffer dst, int length)` Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
    `void` | `readBytes(ChannelBuffer dst, int dstIndex, int length)` Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
    `int` | `readBytes(GatheringByteChannel out, int length)` Transfers this buffer's data to the specified stream starting at the current `readerIndex`.
    `ChannelBuffer` | `readBytes(int length)` Transfers this buffer's data to a newly created buffer starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
    `void` | `readBytes(OutputStream out, int length)` Transfers this buffer's data to the specified stream starting at the current `readerIndex`.
    `char` | `readChar()` Gets a 2-byte UTF-16 character at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
    `double` | `readDouble()` Gets a 64-bit floating point number at the current `readerIndex` and increases the `readerIndex` by `8` in this buffer.
    `int` | `readerIndex()` Returns the `readerIndex` of this buffer.
    `void` | `readerIndex(int readerIndex)` Sets the `readerIndex` of this buffer.
    `float` | `readFloat()` Gets a 32-bit floating point number at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
    `int` | `readInt()` Gets a 32-bit integer at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
    `long` | `readLong()` Gets a 64-bit integer at the current `readerIndex` and increases the `readerIndex` by `8` in this buffer.
    `int` | `readMedium()` Gets a 24-bit medium integer at the current `readerIndex` and increases the `readerIndex` by `3` in this buffer.
    `short` | `readShort()` Gets a 16-bit short integer at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
    `ChannelBuffer` | `readSlice(ChannelBufferIndexFinder indexFinder)` Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `readSlice(int)` instead.
    `ChannelBuffer` | `readSlice(int length)` Returns a new slice of this buffer's sub-region starting at the current `readerIndex` and increases the `readerIndex` by the size of the new slice (= `length`).
    `short` | `readUnsignedByte()` Gets an unsigned byte at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
    `long` | `readUnsignedInt()` Gets an unsigned 32-bit integer at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
    `int` | `readUnsignedMedium()` Gets an unsigned 24-bit medium integer at the current `readerIndex` and increases the `readerIndex` by `3` in this buffer.
    `int` | `readUnsignedShort()` Gets an unsigned 16-bit short integer at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
    `void` | `resetReaderIndex()` Repositions the current `readerIndex` to the marked `readerIndex` in this buffer.
    `void` | `resetWriterIndex()` Repositions the current `writerIndex` to the marked `writerIndex` in this buffer.
    `void` | `setByte(int index, int value)` Sets the specified byte at the specified absolute `index` in this buffer.
    `void` | `setBytes(int index, byte[] src)` Transfers the specified source array's data to this buffer starting at the specified absolute `index`.
    `void` | `setBytes(int index, byte[] src, int srcIndex, int length)` Transfers the specified source array's data to this buffer starting at the specified absolute `index`.
    `void` | `setBytes(int index, ByteBuffer src)` Transfers the specified source buffer's data to this buffer starting at the specified absolute `index` until the source buffer's position reaches its limit.
    `void` | `setBytes(int index, ChannelBuffer src)` Transfers the specified source buffer's data to this buffer starting at the specified absolute `index` until the source buffer becomes unreadable.
    `void` | `setBytes(int index, ChannelBuffer src, int length)` Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`.
    `void` | `setBytes(int index, ChannelBuffer src, int srcIndex, int length)` Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`.
    `int` | `setBytes(int index, InputStream in, int length)` Transfers the content of the specified source stream to this buffer starting at the specified absolute `index`.
    `int` | `setBytes(int index, ScatteringByteChannel in, int length)` Transfers the content of the specified source channel to this buffer starting at the specified absolute `index`.
    `void` | `setChar(int index, int value)` Sets the specified 2-byte UTF-16 character at the specified absolute `index` in this buffer.
    `void` | `setDouble(int index, double value)` Sets the specified 64-bit floating-point number at the specified absolute `index` in this buffer.
    `void` | `setFloat(int index, float value)` Sets the specified 32-bit floating-point number at the specified absolute `index` in this buffer.
    `void` | `setIndex(int readerIndex, int writerIndex)` Sets the `readerIndex` and `writerIndex` of this buffer in one shot.
    `void` | `setInt(int index, int value)` Sets the specified 32-bit integer at the specified absolute `index` in this buffer.
    `void` | `setLong(int index, long value)` Sets the specified 64-bit long integer at the specified absolute `index` in this buffer.
    `void` | `setMedium(int index, int value)` Sets the specified 24-bit medium integer at the specified absolute `index` in this buffer.
    `void` | `setShort(int index, int value)` Sets the specified 16-bit short integer at the specified absolute `index` in this buffer.
    `void` | `setZero(int index, int length)` Fills this buffer with `NUL (0x00)` starting at the specified absolute `index`.
    `int` | `skipBytes(ChannelBufferIndexFinder indexFinder)` Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `skipBytes(int)` instead.
    `void` | `skipBytes(int length)` Increases the current `readerIndex` by the specified `length` in this buffer.
    `ChannelBuffer` | `slice()` Returns a slice of this buffer's readable bytes.
    `ChannelBuffer` | `slice(int index, int length)` Returns a slice of this buffer's sub-region.
    `ByteBuffer` | `toByteBuffer()` Converts this buffer's readable bytes into a NIO buffer.
    `ByteBuffer` | `toByteBuffer(int index, int length)` Converts this buffer's sub-region into a NIO buffer.
    `ByteBuffer[]` | `toByteBuffers()` Converts this buffer's readable bytes into an array of NIO buffers.
    `ByteBuffer[]` | `toByteBuffers(int index, int length)` Converts this buffer's sub-region into an array of NIO buffers.
    `String` | `toString()` Returns the string representation of this buffer.
    `String` | `toString(Charset charset)` Decodes this buffer's readable bytes into a string with the specified character set name.
    `String` | `toString(int index, int length, Charset charset)` Decodes this buffer's sub-region into a string with the specified character set.
    `String` | `toString(int index, int length, String charsetName)` Deprecated. Use `bytesBefore(int, int, ChannelBufferIndexFinder)` and `toString(int, int, Charset)` instead.
    `String` | `toString(int index, int length, String charsetName, ChannelBufferIndexFinder terminatorFinder)` Deprecated. Use `bytesBefore(int, int, ChannelBufferIndexFinder)` and `toString(int, int, Charset)` instead.
    `String` | `toString(String charsetName)` Deprecated. Use `toString(Charset)` instead.
    `String` | `toString(String charsetName, ChannelBufferIndexFinder terminatorFinder)` Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `toString(int, int, Charset)` instead.
    `boolean` | `writable()` Returns `true` if and only if `(this.capacity - this.writerIndex)` is greater than `0`.
    `int` | `writableBytes()` Returns the number of writable bytes which is equal to `(this.capacity - this.writerIndex)`.
    `void` | `writeByte(int value)` Sets the specified byte at the current `writerIndex` and increases the `writerIndex` by `1` in this buffer.
    `void` | `writeBytes(byte[] src)` Transfers the specified source array's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `src.length`).
    `void` | `writeBytes(byte[] src, int srcIndex, int length)` Transfers the specified source array's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
    `void` | `writeBytes(ByteBuffer src)` Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` until the source buffer's position reaches its limit, and increases the `writerIndex` by the number of the transferred bytes.
    `void` | `writeBytes(ChannelBuffer src)` Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` until the source buffer becomes unreadable, and increases the `writerIndex` by the number of the transferred bytes.
    `void` | `writeBytes(ChannelBuffer src, int length)` Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
    `void` | `writeBytes(ChannelBuffer src, int srcIndex, int length)` Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
    `int` | `writeBytes(InputStream in, int length)` Transfers the content of the specified stream to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes.
    `int` | `writeBytes(ScatteringByteChannel in, int length)` Transfers the content of the specified channel to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes.
    `void` | `writeChar(int value)` Sets the specified 2-byte UTF-16 character at the current `writerIndex` and increases the `writerIndex` by `2` in this buffer.
    `void` | `writeDouble(double value)` Sets the specified 64-bit floating point number at the current `writerIndex` and increases the `writerIndex` by `8` in this buffer.
    `void` | `writeFloat(float value)` Sets the specified 32-bit floating point number at the current `writerIndex` and increases the `writerIndex` by `4` in this buffer.
    `void` | `writeInt(int value)` Sets the specified 32-bit integer at the current `writerIndex` and increases the `writerIndex` by `4` in this buffer.
    `void` | `writeLong(long value)` Sets the specified 64-bit long integer at the current `writerIndex` and increases the `writerIndex` by `8` in this buffer.
    `void` | `writeMedium(int value)` Sets the specified 24-bit medium integer at the current `writerIndex` and increases the `writerIndex` by `3` in this buffer.
    `int` | `writerIndex()` Returns the `writerIndex` of this buffer.
    `void` | `writerIndex(int writerIndex)` Sets the `writerIndex` of this buffer.
    `void` | `writeShort(int value)` Sets the specified 16-bit short integer at the current `writerIndex` and increases the `writerIndex` by `2` in this buffer.
    `void` | `writeZero(int length)` Fills this buffer with `NUL (0x00)` starting at the current `writerIndex` and increases the `writerIndex` by the specified `length`.

- - ### Method Detail

    - #### factory

          ChannelBufferFactory factory()

      Returns the factory which creates a `ChannelBuffer` whose type and default `ByteOrder` are same with this buffer.

    - #### capacity

          int capacity()

      Returns the number of bytes (octets) this buffer can contain.

    - #### order

          ByteOrder order()

      Returns the endianness of this buffer.

    - #### isDirect

          boolean isDirect()

      Returns `true` if and only if this buffer is backed by an NIO direct buffer.

    - #### readerIndex

          int readerIndex()

      Returns the `readerIndex` of this buffer.

    - #### readerIndex

          void readerIndex(int readerIndex)

      Sets the `readerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `readerIndex` is less than `0` or greater than `this.writerIndex`

    - #### writerIndex

          int writerIndex()

      Returns the `writerIndex` of this buffer.

    - #### writerIndex

          void writerIndex(int writerIndex)

      Sets the `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `writerIndex` is less than `this.readerIndex` or greater than `this.capacity`

    - #### setIndex

          void setIndex(int readerIndex,
                      int writerIndex)

      Sets the `readerIndex` and `writerIndex` of this buffer in one shot. This method is useful when you have to worry about the invocation order of `readerIndex(int)` and `writerIndex(int)` methods. For example, the following code will fail:

           // Create a buffer whose readerIndex, writerIndex and capacity are
           // 0, 0 and 8 respectively.
           ChannelBuffer buf = ChannelBuffers.buffer(8);

           // IndexOutOfBoundsException is thrown because the specified
           // readerIndex (2) cannot be greater than the current writerIndex (0).
           buf.readerIndex(2);
           buf.writerIndex(4);

      The following code will also fail:

           // Create a buffer whose readerIndex, writerIndex and capacity are
           // 0, 8 and 8 respectively.
           ChannelBuffer buf = ChannelBuffers.wrappedBuffer(new byte[8]);

           // readerIndex becomes 8.
           buf.readLong();

           // IndexOutOfBoundsException is thrown because the specified
           // writerIndex (4) cannot be less than the current readerIndex (8).
           buf.writerIndex(4);
           buf.readerIndex(2);

      By contrast, `setIndex(int, int)` guarantees that it never throws an `IndexOutOfBoundsException` as long as the specified indexes meet basic constraints, regardless what the current index values of the buffer are:

           // No matter what the current state of the buffer is, the following
           // call always succeeds as long as the capacity of the buffer is not
           // less than 4.
           buf.setIndex(2, 4);

      Throws:
        `IndexOutOfBoundsException` - if the specified `readerIndex` is less than 0, if the specified `writerIndex` is less than the specified `readerIndex` or if the specified `writerIndex` is greater than `this.capacity`

    - #### readableBytes

          int readableBytes()

      Returns the number of readable bytes which is equal to `(this.writerIndex - this.readerIndex)`.

    - #### writableBytes

          int writableBytes()

      Returns the number of writable bytes which is equal to `(this.capacity - this.writerIndex)`.

    - #### readable

          boolean readable()

      Returns `true` if and only if `(this.writerIndex - this.readerIndex)` is greater than `0`.

    - #### writable

          boolean writable()

      Returns `true` if and only if `(this.capacity - this.writerIndex)` is greater than `0`.

    - #### clear

          void clear()

      Sets the `readerIndex` and `writerIndex` of this buffer to `0`. This method is identical to `setIndex(0, 0)`.

      Please note that the behavior of this method is different from that of NIO buffer, which sets the `limit` to the `capacity` of the buffer.

    - #### markReaderIndex

          void markReaderIndex()

      Marks the current `readerIndex` in this buffer. You can reposition the current `readerIndex` to the marked `readerIndex` by calling `resetReaderIndex()`. The initial value of the marked `readerIndex` is `0`.

    - #### resetReaderIndex

          void resetReaderIndex()

      Repositions the current `readerIndex` to the marked `readerIndex` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the current `writerIndex` is less than the marked `readerIndex`

    - #### markWriterIndex

          void markWriterIndex()

      Marks the current `writerIndex` in this buffer. You can reposition the current `writerIndex` to the marked `writerIndex` by calling `resetWriterIndex()`. The initial value of the marked `writerIndex` is `0`.

    - #### resetWriterIndex

          void resetWriterIndex()

      Repositions the current `writerIndex` to the marked `writerIndex` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the current `readerIndex` is greater than the marked `writerIndex`

    - #### discardReadBytes

          void discardReadBytes()

      Discards the bytes between the 0th index and `readerIndex`. It moves the bytes between `readerIndex` and `writerIndex` to the 0th index, and sets `readerIndex` and `writerIndex` to `0` and `oldWriterIndex - oldReaderIndex` respectively.

      Please refer to the class documentation for more detailed explanation.

    - #### ensureWritableBytes

          void ensureWritableBytes(int writableBytes)

      Makes sure the number of the writable bytes is equal to or greater than the specified value. If there is enough writable bytes in this buffer, this method returns with no side effect. Otherwise:
      - a non-dynamic buffer will throw an `IndexOutOfBoundsException`.
      - a dynamic buffer will expand its capacity so that the number of the `writable bytes` becomes equal to or greater than the specified value. The expansion involves the reallocation of the internal buffer and consequently memory copy.
      Parameters:
        `writableBytes` - the expected minimum number of writable bytes
      Throws:
        `IndexOutOfBoundsException` - if the writable bytes of this buffer is less than the specified value and if this buffer is not a dynamic buffer

    - #### getByte

          byte getByte(int index)

      Gets a byte at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 1` is greater than `this.capacity`

    - #### getUnsignedByte

          short getUnsignedByte(int index)

      Gets an unsigned byte at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 1` is greater than `this.capacity`

    - #### getShort

          short getShort(int index)

      Gets a 16-bit short integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 2` is greater than `this.capacity`

    - #### getUnsignedShort

          int getUnsignedShort(int index)

      Gets an unsigned 16-bit short integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 2` is greater than `this.capacity`

    - #### getMedium

          int getMedium(int index)

      Gets a 24-bit medium integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 3` is greater than `this.capacity`

    - #### getUnsignedMedium

          int getUnsignedMedium(int index)

      Gets an unsigned 24-bit medium integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 3` is greater than `this.capacity`

    - #### getInt

          int getInt(int index)

      Gets a 32-bit integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 4` is greater than `this.capacity`

    - #### getUnsignedInt

          long getUnsignedInt(int index)

      Gets an unsigned 32-bit integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 4` is greater than `this.capacity`

    - #### getLong

          long getLong(int index)

      Gets a 64-bit long integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 8` is greater than `this.capacity`

    - #### getChar

          char getChar(int index)

      Gets a 2-byte UTF-16 character at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 2` is greater than `this.capacity`

    - #### getFloat

          float getFloat(int index)

      Gets a 32-bit floating point number at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 4` is greater than `this.capacity`

    - #### getDouble

          double getDouble(int index)

      Gets a 64-bit floating point number at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 8` is greater than `this.capacity`

    - #### getBytes

          void getBytes(int index,
                      ChannelBuffer dst)

      Transfers this buffer's data to the specified destination starting at the specified absolute `index` until the destination becomes non-writable. This method is basically same with `getBytes(int, ChannelBuffer, int, int)`, except that this method increases the `writerIndex` of the destination by the number of the transferred bytes while `getBytes(int, ChannelBuffer, int, int)` does not. This method does not modify `readerIndex` or `writerIndex` of the source buffer (i.e. `this`).
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + dst.writableBytes` is greater than `this.capacity`

    - #### getBytes

          void getBytes(int index,
                      ChannelBuffer dst,
                      int length)

      Transfers this buffer's data to the specified destination starting at the specified absolute `index`. This method is basically same with `getBytes(int, ChannelBuffer, int, int)`, except that this method increases the `writerIndex` of the destination by the number of the transferred bytes while `getBytes(int, ChannelBuffer, int, int)` does not. This method does not modify `readerIndex` or `writerIndex` of the source buffer (i.e. `this`).
      Parameters:
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0`, if `index + length` is greater than `this.capacity`, or if `length` is greater than `dst.writableBytes`

    - #### getBytes

          void getBytes(int index,
                      ChannelBuffer dst,
                      int dstIndex,
                      int length)

      Transfers this buffer's data to the specified destination starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of both the source (i.e. `this`) and the destination.
      Parameters:
        `dstIndex` - the first index of the destination
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0`, if the specified `dstIndex` is less than `0`, if `index + length` is greater than `this.capacity`, or if `dstIndex + length` is greater than `dst.capacity`

    - #### getBytes

          void getBytes(int index,
                      byte[] dst)

      Transfers this buffer's data to the specified destination starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + dst.length` is greater than `this.capacity`

    - #### getBytes

          void getBytes(int index,
                      byte[] dst,
                      int dstIndex,
                      int length)

      Transfers this buffer's data to the specified destination starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Parameters:
        `dstIndex` - the first index of the destination
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0`, if the specified `dstIndex` is less than `0`, if `index + length` is greater than `this.capacity`, or if `dstIndex + length` is greater than `dst.length`

    - #### getBytes

          void getBytes(int index,
                      ByteBuffer dst)

      Transfers this buffer's data to the specified destination starting at the specified absolute `index` until the destination's position reaches its limit. This method does not modify `readerIndex` or `writerIndex` of this buffer while the destination's `position` will be increased.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + dst.remaining()` is greater than `this.capacity`

    - #### getBytes

          void getBytes(int index,
                      OutputStream out,
                      int length)
                        throws IOException

      Transfers this buffer's data to the specified stream starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Parameters:
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + length` is greater than `this.capacity`
        `IOException` - if the specified stream threw an exception during I/O

    - #### getBytes

          int getBytes(int index,
                     GatheringByteChannel out,
                     int length)
                       throws IOException

      Transfers this buffer's data to the specified channel starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Parameters:
        `length` - the maximum number of bytes to transfer
      Returns:
        the actual number of bytes written out to the specified channel
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + length` is greater than `this.capacity`
        `IOException` - if the specified channel threw an exception during I/O

    - #### setByte

          void setByte(int index,
                     int value)

      Sets the specified byte at the specified absolute `index` in this buffer. The 24 high-order bits of the specified value are ignored. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 1` is greater than `this.capacity`

    - #### setShort

          void setShort(int index,
                      int value)

      Sets the specified 16-bit short integer at the specified absolute `index` in this buffer. The 16 high-order bits of the specified value are ignored. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 2` is greater than `this.capacity`

    - #### setMedium

          void setMedium(int index,
                       int value)

      Sets the specified 24-bit medium integer at the specified absolute `index` in this buffer. Please note that the most significant byte is ignored in the specified value. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 3` is greater than `this.capacity`

    - #### setInt

          void setInt(int index,
                    int value)

      Sets the specified 32-bit integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 4` is greater than `this.capacity`

    - #### setLong

          void setLong(int index,
                     long value)

      Sets the specified 64-bit long integer at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 8` is greater than `this.capacity`

    - #### setChar

          void setChar(int index,
                     int value)

      Sets the specified 2-byte UTF-16 character at the specified absolute `index` in this buffer. The 16 high-order bits of the specified value are ignored. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 2` is greater than `this.capacity`

    - #### setFloat

          void setFloat(int index,
                      float value)

      Sets the specified 32-bit floating-point number at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 4` is greater than `this.capacity`

    - #### setDouble

          void setDouble(int index,
                       double value)

      Sets the specified 64-bit floating-point number at the specified absolute `index` in this buffer. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or `index + 8` is greater than `this.capacity`

    - #### setBytes

          void setBytes(int index,
                      ChannelBuffer src)

      Transfers the specified source buffer's data to this buffer starting at the specified absolute `index` until the source buffer becomes unreadable. This method is basically same with `setBytes(int, ChannelBuffer, int, int)`, except that this method increases the `readerIndex` of the source buffer by the number of the transferred bytes while `setBytes(int, ChannelBuffer, int, int)` does not. This method does not modify `readerIndex` or `writerIndex` of the source buffer (i.e. `this`).
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + src.readableBytes` is greater than `this.capacity`

    - #### setBytes

          void setBytes(int index,
                      ChannelBuffer src,
                      int length)

      Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`. This method is basically same with `setBytes(int, ChannelBuffer, int, int)`, except that this method increases the `readerIndex` of the source buffer by the number of the transferred bytes while `setBytes(int, ChannelBuffer, int, int)` does not. This method does not modify `readerIndex` or `writerIndex` of the source buffer (i.e. `this`).
      Parameters:
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0`, if `index + length` is greater than `this.capacity`, or if `length` is greater than `src.readableBytes`

    - #### setBytes

          void setBytes(int index,
                      ChannelBuffer src,
                      int srcIndex,
                      int length)

      Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of both the source (i.e. `this`) and the destination.
      Parameters:
        `srcIndex` - the first index of the source
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0`, if the specified `srcIndex` is less than `0`, if `index + length` is greater than `this.capacity`, or if `srcIndex + length` is greater than `src.capacity`

    - #### setBytes

          void setBytes(int index,
                      byte[] src)

      Transfers the specified source array's data to this buffer starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + src.length` is greater than `this.capacity`

    - #### setBytes

          void setBytes(int index,
                      byte[] src,
                      int srcIndex,
                      int length)

      Transfers the specified source array's data to this buffer starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0`, if the specified `srcIndex` is less than `0`, if `index + length` is greater than `this.capacity`, or if `srcIndex + length` is greater than `src.length`

    - #### setBytes

          void setBytes(int index,
                      ByteBuffer src)

      Transfers the specified source buffer's data to this buffer starting at the specified absolute `index` until the source buffer's position reaches its limit. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + src.remaining()` is greater than `this.capacity`

    - #### setBytes

          int setBytes(int index,
                     InputStream in,
                     int length)
                       throws IOException

      Transfers the content of the specified source stream to this buffer starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Parameters:
        `length` - the number of bytes to transfer
      Returns:
        the actual number of bytes read in from the specified channel. `-1` if the specified channel is closed.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + length` is greater than `this.capacity`
        `IOException` - if the specified stream threw an exception during I/O

    - #### setBytes

          int setBytes(int index,
                     ScatteringByteChannel in,
                     int length)
                       throws IOException

      Transfers the content of the specified source channel to this buffer starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Parameters:
        `length` - the maximum number of bytes to transfer
      Returns:
        the actual number of bytes read in from the specified channel. `-1` if the specified channel is closed.
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + length` is greater than `this.capacity`
        `IOException` - if the specified channel threw an exception during I/O

    - #### setZero

          void setZero(int index,
                     int length)

      Fills this buffer with `NUL (0x00)` starting at the specified absolute `index`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Parameters:
        `length` - the number of `NUL`s to write to the buffer
      Throws:
        `IndexOutOfBoundsException` - if the specified `index` is less than `0` or if `index + length` is greater than `this.capacity`

    - #### readByte

          byte readByte()

      Gets a byte at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `1`

    - #### readUnsignedByte

          short readUnsignedByte()

      Gets an unsigned byte at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `1`

    - #### readShort

          short readShort()

      Gets a 16-bit short integer at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `2`

    - #### readUnsignedShort

          int readUnsignedShort()

      Gets an unsigned 16-bit short integer at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `2`

    - #### readMedium

          int readMedium()

      Gets a 24-bit medium integer at the current `readerIndex` and increases the `readerIndex` by `3` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `3`

    - #### readUnsignedMedium

          int readUnsignedMedium()

      Gets an unsigned 24-bit medium integer at the current `readerIndex` and increases the `readerIndex` by `3` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `3`

    - #### readInt

          int readInt()

      Gets a 32-bit integer at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `4`

    - #### readUnsignedInt

          long readUnsignedInt()

      Gets an unsigned 32-bit integer at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `4`

    - #### readLong

          long readLong()

      Gets a 64-bit integer at the current `readerIndex` and increases the `readerIndex` by `8` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `8`

    - #### readChar

          char readChar()

      Gets a 2-byte UTF-16 character at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `2`

    - #### readFloat

          float readFloat()

      Gets a 32-bit floating point number at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `4`

    - #### readDouble

          double readDouble()

      Gets a 64-bit floating point number at the current `readerIndex` and increases the `readerIndex` by `8` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.readableBytes` is less than `8`

    - #### readBytes

          ChannelBuffer readBytes(int length)

      Transfers this buffer's data to a newly created buffer starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`). The returned buffer's `readerIndex` and `writerIndex` are `0` and `length` respectively.
      Parameters:
        `length` - the number of bytes to transfer
      Returns:
        the newly created buffer which contains the transferred bytes
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes`

    - #### readBytes

          @Deprecated
          ChannelBuffer readBytes(ChannelBufferIndexFinder indexFinder)

      Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `readBytes(int)` instead.

    - #### readSlice

          ChannelBuffer readSlice(int length)

      Returns a new slice of this buffer's sub-region starting at the current `readerIndex` and increases the `readerIndex` by the size of the new slice (= `length`).
      Parameters:
        `length` - the size of the new slice
      Returns:
        the newly created slice
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes`

    - #### readSlice

          @Deprecated
          ChannelBuffer readSlice(ChannelBufferIndexFinder indexFinder)

      Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `readSlice(int)` instead.

    - #### readBytes

          void readBytes(ChannelBuffer dst)

      Transfers this buffer's data to the specified destination starting at the current `readerIndex` until the destination becomes non-writable, and increases the `readerIndex` by the number of the transferred bytes. This method is basically same with `readBytes(ChannelBuffer, int, int)`, except that this method increases the `writerIndex` of the destination by the number of the transferred bytes while `readBytes(ChannelBuffer, int, int)` does not.
      Throws:
        `IndexOutOfBoundsException` - if `dst.writableBytes` is greater than `this.readableBytes`

    - #### readBytes

          void readBytes(ChannelBuffer dst,
                       int length)

      Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`). This method is basically same with `readBytes(ChannelBuffer, int, int)`, except that this method increases the `writerIndex` of the destination by the number of the transferred bytes (= `length`) while `readBytes(ChannelBuffer, int, int)` does not.
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes` or if `length` is greater than `dst.writableBytes`

    - #### readBytes

          void readBytes(ChannelBuffer dst,
                       int dstIndex,
                       int length)

      Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
      Parameters:
        `dstIndex` - the first index of the destination
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `dstIndex` is less than `0`, if `length` is greater than `this.readableBytes`, or if `dstIndex + length` is greater than `dst.capacity`

    - #### readBytes

          void readBytes(byte[] dst)

      Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `dst.length`).
      Throws:
        `IndexOutOfBoundsException` - if `dst.length` is greater than `this.readableBytes`

    - #### readBytes

          void readBytes(byte[] dst,
                       int dstIndex,
                       int length)

      Transfers this buffer's data to the specified destination starting at the current `readerIndex` and increases the `readerIndex` by the number of the transferred bytes (= `length`).
      Parameters:
        `dstIndex` - the first index of the destination
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `dstIndex` is less than `0`, if `length` is greater than `this.readableBytes`, or if `dstIndex + length` is greater than `dst.length`

    - #### readBytes

          void readBytes(ByteBuffer dst)

      Transfers this buffer's data to the specified destination starting at the current `readerIndex` until the destination's position reaches its limit, and increases the `readerIndex` by the number of the transferred bytes.
      Throws:
        `IndexOutOfBoundsException` - if `dst.remaining()` is greater than `this.readableBytes`

    - #### readBytes

          void readBytes(OutputStream out,
                       int length)
                         throws IOException

      Transfers this buffer's data to the specified stream starting at the current `readerIndex`.
      Parameters:
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes`
        `IOException` - if the specified stream threw an exception during I/O

    - #### readBytes

          int readBytes(GatheringByteChannel out,
                      int length)
                        throws IOException

      Transfers this buffer's data to the specified stream starting at the current `readerIndex`.
      Parameters:
        `length` - the maximum number of bytes to transfer
      Returns:
        the actual number of bytes written out to the specified channel
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes`
        `IOException` - if the specified channel threw an exception during I/O

    - #### skipBytes

          void skipBytes(int length)

      Increases the current `readerIndex` by the specified `length` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes`

    - #### skipBytes

          @Deprecated
          int skipBytes(ChannelBufferIndexFinder indexFinder)

      Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `skipBytes(int)` instead.

    - #### writeByte

          void writeByte(int value)

      Sets the specified byte at the current `writerIndex` and increases the `writerIndex` by `1` in this buffer. The 24 high-order bits of the specified value are ignored.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `1`

    - #### writeShort

          void writeShort(int value)

      Sets the specified 16-bit short integer at the current `writerIndex` and increases the `writerIndex` by `2` in this buffer. The 16 high-order bits of the specified value are ignored.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `2`

    - #### writeMedium

          void writeMedium(int value)

      Sets the specified 24-bit medium integer at the current `writerIndex` and increases the `writerIndex` by `3` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `3`

    - #### writeInt

          void writeInt(int value)

      Sets the specified 32-bit integer at the current `writerIndex` and increases the `writerIndex` by `4` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `4`

    - #### writeLong

          void writeLong(long value)

      Sets the specified 64-bit long integer at the current `writerIndex` and increases the `writerIndex` by `8` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `8`

    - #### writeChar

          void writeChar(int value)

      Sets the specified 2-byte UTF-16 character at the current `writerIndex` and increases the `writerIndex` by `2` in this buffer. The 16 high-order bits of the specified value are ignored.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `2`

    - #### writeFloat

          void writeFloat(float value)

      Sets the specified 32-bit floating point number at the current `writerIndex` and increases the `writerIndex` by `4` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `4`

    - #### writeDouble

          void writeDouble(double value)

      Sets the specified 64-bit floating point number at the current `writerIndex` and increases the `writerIndex` by `8` in this buffer.
      Throws:
        `IndexOutOfBoundsException` - if `this.writableBytes` is less than `8`

    - #### writeBytes

          void writeBytes(ChannelBuffer src)

      Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` until the source buffer becomes unreadable, and increases the `writerIndex` by the number of the transferred bytes. This method is basically same with `writeBytes(ChannelBuffer, int, int)`, except that this method increases the `readerIndex` of the source buffer by the number of the transferred bytes while `writeBytes(ChannelBuffer, int, int)` does not.
      Throws:
        `IndexOutOfBoundsException` - if `src.readableBytes` is greater than `this.writableBytes`

    - #### writeBytes

          void writeBytes(ChannelBuffer src,
                        int length)

      Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`). This method is basically same with `writeBytes(ChannelBuffer, int, int)`, except that this method increases the `readerIndex` of the source buffer by the number of the transferred bytes (= `length`) while `writeBytes(ChannelBuffer, int, int)` does not.
      Parameters:
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.writableBytes` or if `length` is greater then `src.readableBytes`

    - #### writeBytes

          void writeBytes(ChannelBuffer src,
                        int srcIndex,
                        int length)

      Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
      Parameters:
        `srcIndex` - the first index of the source
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `srcIndex` is less than `0`, if `srcIndex + length` is greater than `src.capacity`, or if `length` is greater than `this.writableBytes`

    - #### writeBytes

          void writeBytes(byte[] src)

      Transfers the specified source array's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `src.length`).
      Throws:
        `IndexOutOfBoundsException` - if `src.length` is greater than `this.writableBytes`

    - #### writeBytes

          void writeBytes(byte[] src,
                        int srcIndex,
                        int length)

      Transfers the specified source array's data to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes (= `length`).
      Parameters:
        `srcIndex` - the first index of the source
        `length` - the number of bytes to transfer
      Throws:
        `IndexOutOfBoundsException` - if the specified `srcIndex` is less than `0`, if `srcIndex + length` is greater than `src.length`, or if `length` is greater than `this.writableBytes`

    - #### writeBytes

          void writeBytes(ByteBuffer src)

      Transfers the specified source buffer's data to this buffer starting at the current `writerIndex` until the source buffer's position reaches its limit, and increases the `writerIndex` by the number of the transferred bytes.
      Throws:
        `IndexOutOfBoundsException` - if `src.remaining()` is greater than `this.writableBytes`

    - #### writeBytes

          int writeBytes(InputStream in,
                       int length)
                         throws IOException

      Transfers the content of the specified stream to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes.
      Parameters:
        `length` - the number of bytes to transfer
      Returns:
        the actual number of bytes read in from the specified stream
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.writableBytes`
        `IOException` - if the specified stream threw an exception during I/O

    - #### writeBytes

          int writeBytes(ScatteringByteChannel in,
                       int length)
                         throws IOException

      Transfers the content of the specified channel to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes.
      Parameters:
        `length` - the maximum number of bytes to transfer
      Returns:
        the actual number of bytes read in from the specified channel
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.writableBytes`
        `IOException` - if the specified channel threw an exception during I/O

    - #### writeZero

          void writeZero(int length)

      Fills this buffer with `NUL (0x00)` starting at the current `writerIndex` and increases the `writerIndex` by the specified `length`.
      Parameters:
        `length` - the number of `NUL`s to write to the buffer
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.writableBytes`

    - #### indexOf

          int indexOf(int fromIndex,
                    int toIndex,
                    byte value)

      Locates the first occurrence of the specified `value` in this buffer. The search takes place from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive).

      If `fromIndex` is greater than `toIndex`, the search is performed in a reversed order.

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the absolute index of the first occurrence if found. `-1` otherwise.

    - #### indexOf

          int indexOf(int fromIndex,
                    int toIndex,
                    ChannelBufferIndexFinder indexFinder)

      Locates the first place where the specified `indexFinder` returns `true`. The search takes place from the specified `fromIndex` (inclusive) to the specified `toIndex` (exclusive).

      If `fromIndex` is greater than `toIndex`, the search is performed in a reversed order.

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the absolute index where the specified `indexFinder` returned `true`. `-1` if the `indexFinder` did not return `true` at all.

    - #### bytesBefore

          int bytesBefore(byte value)

      Locates the first occurrence of the specified `value` in this buffer. The search takes place from the current `readerIndex` (inclusive) to the current `writerIndex` (exclusive).

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the number of bytes between the current `readerIndex` and the first occurrence if found. `-1` otherwise.

    - #### bytesBefore

          int bytesBefore(ChannelBufferIndexFinder indexFinder)

      Locates the first place where the specified `indexFinder` returns `true`. The search takes place from the current `readerIndex` (inclusive) to the current `writerIndex`.

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the number of bytes between the current `readerIndex` and the first place where the `indexFinder` returned `true`. `-1` if the `indexFinder` did not return `true` at all.

    - #### bytesBefore

          int bytesBefore(int length,
                        byte value)

      Locates the first occurrence of the specified `value` in this buffer. The search starts from the current `readerIndex` (inclusive) and lasts for the specified `length`.

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the number of bytes between the current `readerIndex` and the first occurrence if found. `-1` otherwise.
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes`

    - #### bytesBefore

          int bytesBefore(int length,
                        ChannelBufferIndexFinder indexFinder)

      Locates the first place where the specified `indexFinder` returns `true`. The search starts the current `readerIndex` (inclusive) and lasts for the specified `length`.

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the number of bytes between the current `readerIndex` and the first place where the `indexFinder` returned `true`. `-1` if the `indexFinder` did not return `true` at all.
      Throws:
        `IndexOutOfBoundsException` - if `length` is greater than `this.readableBytes`

    - #### bytesBefore

          int bytesBefore(int index,
                        int length,
                        byte value)

      Locates the first occurrence of the specified `value` in this buffer. The search starts from the specified `index` (inclusive) and lasts for the specified `length`.

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the number of bytes between the specified `index` and the first occurrence if found. `-1` otherwise.
      Throws:
        `IndexOutOfBoundsException` - if `index + length` is greater than `this.capacity`

    - #### bytesBefore

          int bytesBefore(int index,
                        int length,
                        ChannelBufferIndexFinder indexFinder)

      Locates the first place where the specified `indexFinder` returns `true`. The search starts the specified `index` (inclusive) and lasts for the specified `length`.

      This method does not modify `readerIndex` or `writerIndex` of this buffer.

      Returns:
        the number of bytes between the specified `index` and the first place where the `indexFinder` returned `true`. `-1` if the `indexFinder` did not return `true` at all.
      Throws:
        `IndexOutOfBoundsException` - if `index + length` is greater than `this.capacity`

    - #### copy

          ChannelBuffer copy()

      Returns a copy of this buffer's readable bytes. Modifying the content of the returned buffer or this buffer does not affect each other at all. This method is identical to `buf.copy(buf.readerIndex(), buf.readableBytes())`. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### copy

          ChannelBuffer copy(int index,
                           int length)

      Returns a copy of this buffer's sub-region. Modifying the content of the returned buffer or this buffer does not affect each other at all. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### slice

          ChannelBuffer slice()

      Returns a slice of this buffer's readable bytes. Modifying the content of the returned buffer or this buffer affects each other's content while they maintain separate indexes and marks. This method is identical to `buf.slice(buf.readerIndex(), buf.readableBytes())`. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### slice

          ChannelBuffer slice(int index,
                            int length)

      Returns a slice of this buffer's sub-region. Modifying the content of the returned buffer or this buffer affects each other's content while they maintain separate indexes and marks. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### duplicate

          ChannelBuffer duplicate()

      Returns a buffer which shares the whole region of this buffer. Modifying the content of the returned buffer or this buffer affects each other's content while they maintain separate indexes and marks. This method is identical to `buf.slice(0, buf.capacity())`. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### toByteBuffer

          ByteBuffer toByteBuffer()

      Converts this buffer's readable bytes into a NIO buffer. The returned buffer might or might not share the content with this buffer, while they have separate indexes and marks. This method is identical to `buf.toByteBuffer(buf.readerIndex(), buf.readableBytes())`. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### toByteBuffer

          ByteBuffer toByteBuffer(int index,
                                int length)

      Converts this buffer's sub-region into a NIO buffer. The returned buffer might or might not share the content with this buffer, while they have separate indexes and marks. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### toByteBuffers

          ByteBuffer[] toByteBuffers()

      Converts this buffer's readable bytes into an array of NIO buffers. The returned buffers might or might not share the content with this buffer, while they have separate indexes and marks. This method is identical to `buf.toByteBuffers(buf.readerIndex(), buf.readableBytes())`. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### toByteBuffers

          ByteBuffer[] toByteBuffers(int index,
                                   int length)

      Converts this buffer's sub-region into an array of NIO buffers. The returned buffers might or might not share the content with this buffer, while they have separate indexes and marks. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### hasArray

          boolean hasArray()

      Returns `true` if and only if this buffer has a backing byte array. If this method returns true, you can safely call `array()` and `arrayOffset()`.

    - #### array

          byte[] array()

      Returns the backing byte array of this buffer.
      Throws:
        `UnsupportedOperationException` - if there no accessible backing byte array

    - #### arrayOffset

          int arrayOffset()

      Returns the offset of the first byte within the backing byte array of this buffer.
      Throws:
        `UnsupportedOperationException` - if there no accessible backing byte array

    - #### toString

          String toString(Charset charset)

      Decodes this buffer's readable bytes into a string with the specified character set name. This method is identical to `buf.toString(buf.readerIndex(), buf.readableBytes(), charsetName)`. This method does not modify `readerIndex` or `writerIndex` of this buffer.
      Throws:
        `UnsupportedCharsetException` - if the specified character set name is not supported by the current VM

    - #### toString

          String toString(int index,
                        int length,
                        Charset charset)

      Decodes this buffer's sub-region into a string with the specified character set. This method does not modify `readerIndex` or `writerIndex` of this buffer.

    - #### toString

          @Deprecated
          String toString(String charsetName)

      Deprecated. Use `toString(Charset)` instead.

    - #### toString

          @Deprecated
          String toString(String charsetName,
                                   ChannelBufferIndexFinder terminatorFinder)

      Deprecated. Use `bytesBefore(ChannelBufferIndexFinder)` and `toString(int, int, Charset)` instead.

    - #### toString

          @Deprecated
          String toString(int index,
                                   int length,
                                   String charsetName)

      Deprecated. Use `bytesBefore(int, int, ChannelBufferIndexFinder)` and `toString(int, int, Charset)` instead.

    - #### toString

          @Deprecated
          String toString(int index,
                                   int length,
                                   String charsetName,
                                   ChannelBufferIndexFinder terminatorFinder)

      Deprecated. Use `bytesBefore(int, int, ChannelBufferIndexFinder)` and `toString(int, int, Charset)` instead.

    - #### hashCode

          int hashCode()

      Returns a hash code which was calculated from the content of this buffer. If there's a byte array which is equal to this array, both arrays should return the same value.
      Overrides:
        `hashCode` in class `Object`

    - #### equals

          boolean equals(Object obj)

      Determines if the content of the specified buffer is identical to the content of this array. 'Identical' here means:
      - the size of the contents of the two buffers are same and
      - every single byte of the content of the two buffers are same.
      Please note that it does not compare `readerIndex()` nor `writerIndex()`. This method also returns `false` for `null` and an object which is not an instance of `ChannelBuffer` type.
      Overrides:
        `equals` in class `Object`

    - #### compareTo

          int compareTo(ChannelBuffer buffer)

      Compares the content of the specified buffer to the content of this buffer. Comparison is performed in the same manner with the string comparison functions of various languages such as `strcmp`, `memcmp` and `String.compareTo(String)`.
      Specified by:
        `compareTo` in interface `Comparable<ChannelBuffer>`

    - #### toString

          String toString()

      Returns the string representation of this buffer. This method does not necessarily return the whole content of the buffer but returns the values of the key properties such as `readerIndex()`, `writerIndex()` and `capacity()`.
      Overrides:
        `toString` in class `Object`

Copyright © 2008-2012 The Netty Project. All Rights Reserved.