ByteBuf (Netty/Buffer 4.0.0.Alpha3 API)

All Superinterfaces:

ChannelBuf, Comparable<ByteBuf>

All Known Subinterfaces:

CompositeByteBuf, WrappedByteBuf

All Known Implementing Classes:

AbstractByteBuf, DefaultCompositeByteBuf, DirectByteBuf, DuplicatedByteBuf, HeapByteBuf, ReadOnlyByteBuf, SlicedByteBuf, SwappedByteBuf
```
public interface ByteBuf
extends ChannelBuf, Comparable<ByteBuf>
```
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 Unpooled rather than calling an individual implementation's constructor.
Random Access Indexing
Just like an ordinary primitive byte array, ByteBuf 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:
```
 ByteBuf buffer = ...;
 for (int i = 0; i < buffer.capacity(); i ++) {
     byte b = buffer.getByte(i);
     System.out.println((char) b);
 }
 
```
Sequential Access Indexing
ByteBuf 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 ByteBuf 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.
 ByteBuf 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 ByteBuf, 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.
 ByteBuf 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 ByteBufIndexFinder 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 ByteBuf 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
If a ByteBuf can be converted into an NIO ByteBuffer which shares its content (i.e. view buffer), you can get it via the nioBuffer() method. To determine if a buffer can be converted into an NIO buffer, use nioBuffer().
Strings
Various toString(Charset) methods convert a ByteBuf into a String. Please note that toString() is not a conversion method.
I/O Streams
Please refer to ByteBufInputStream and ByteBufOutputStream.

Nested Class Summary

Nested Classes
Modifier and Type Interface and Description

static interface ByteBuf.Unsafe

Nested Classes
Modifier and Type	Interface and Description
`static interface`	`ByteBuf.Unsafe`

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(ByteBufIndexFinder 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, ByteBufIndexFinder 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, ByteBufIndexFinder indexFinder)` Locates the first place where the specified `indexFinder` returns `true`.
`int`	`capacity()` Returns the number of bytes (octets) this buffer can contain.
`void`	`capacity(int newCapacity)` Adjusts the capacity of this buffer.
`void`	`clear()` Sets the `readerIndex` and `writerIndex` of this buffer to `0`.
`int`	`compareTo(ByteBuf buffer)` Compares the content of the specified buffer to the content of this buffer.
`ByteBuf`	`copy()` Returns a copy of this buffer's readable bytes.
`ByteBuf`	`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`.
`ByteBuf`	`duplicate()` Returns a buffer which shares the whole region of this buffer.
`void`	`ensureWritableBytes(int minWritableBytes)` Makes sure the number of the writable bytes is equal to or greater than the specified value.
`int`	`ensureWritableBytes(int minWritableBytes, boolean force)` Tries to make 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.
`boolean`	`getBoolean(int index)` Gets a boolean at the specified absolute (@code index) in 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, ByteBuf 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, 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, ByteBuf dst, int length)` Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`void`	`getBytes(int index, ByteBuf 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.
`boolean`	`hasNioBuffer()` Returns `true` if and only if `nioBuffer()` method will not fail.
`boolean`	`hasNioBuffers()` Returns `true` if and only if `nioBuffers()` method will not fail.
`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, ByteBufIndexFinder 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.
`int`	`maxCapacity()` Returns the maximum allowed capacity of this buffer.
`ByteBuffer`	`nioBuffer()` Exposes this buffer's readable bytes as an NIO `ByteBuffer`.
`ByteBuffer`	`nioBuffer(int index, int length)` Exposes this buffer's sub-region as an NIO `ByteBuffer`.
`ByteBuffer[]`	`nioBuffers()` Exposes this buffer's readable bytes as an NIO `ByteBuffer`'s.
`ByteBuffer[]`	`nioBuffers(int offset, int length)` Exposes this buffer's bytes as an NIO `ByteBuffer`'s for the specified offset and length The returned buffer shares the content with this buffer, while changing the position and limit of the returned NIO buffer does not affect the indexes and marks of this buffer.
`ByteOrder`	`order()` Returns the endianness of this buffer.
`ByteBuf`	`order(ByteOrder endianness)` Returns a buffer with the specified `endianness` which shares the whole region, indexes, and marks 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)`.
`boolean`	`readBoolean()` Gets a boolean at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
`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(ByteBuf 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.
`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(ByteBuf 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(ByteBuf 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`.
`ByteBuf`	`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.
`ByteBuf`	`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`	`setBoolean(int index, boolean value)` Sets the specified boolean at the specified absolute `index` 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, ByteBuf 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, 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, ByteBuf src, int length)` Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`.
`void`	`setBytes(int index, ByteBuf 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`.
`void`	`skipBytes(int length)` Increases the current `readerIndex` by the specified `length` in this buffer.
`ByteBuf`	`slice()` Returns a slice of this buffer's readable bytes.
`ByteBuf`	`slice(int index, int length)` Returns a slice of this buffer's sub-region.
`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.
`ByteBuf.Unsafe`	`unsafe()` Returns an object that exposes unsafe expert-only operations which can lead to unspecified behavior.
`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`	`writeBoolean(boolean value)` Sets the specified boolean at the current `writerIndex` and increases the `writerIndex` by `1` in this buffer.
`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(ByteBuf 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(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(ByteBuf 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(ByteBuf 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`.

Methods inherited from interface io.netty.buffer.ChannelBuf
isPooled, type

- Method Detail
  - capacity
```
int capacity()
```
    Returns the number of bytes (octets) this buffer can contain.
  - capacity
```
void capacity(int newCapacity)
```
    Adjusts the capacity of this buffer. If the newCapacity is less than the current capacity, the content of this buffer is truncated. If the newCapacity is greater than the current capacity, the buffer is appended with unspecified data whose length is (newCapacity - currentCapacity).
  - maxCapacity
```
int maxCapacity()
```
    Returns the maximum allowed capacity of this buffer. If a user attempts to increase the capacity of this buffer beyond the maximum capacity using capacity(int) or ensureWritableBytes(int), those methods will raise an IllegalArgumentException.
  - order
```
ByteOrder order()
```
    Returns the endianness of this buffer.
  - order
```
ByteBuf order(ByteOrder endianness)
```
    Returns a buffer with the specified endianness which shares the whole region, indexes, and marks of this buffer. Modifying the content, the indexes, or the marks of the returned buffer or this buffer affects each other's content, indexes, and marks. If the specified endianness is identical to this buffer's byte order, this method can return this. This method does not modify readerIndex or writerIndex 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.
 ByteBuf buf = Unpooled.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.
 ByteBuf buf = Unpooled.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 minWritableBytes)
```
    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, it raises an IllegalArgumentException.
    
    Parameters:
    minWritableBytes - the expected minimum number of writable bytes
    
    Throws:
    
    IndexOutOfBoundsException - if writerIndex() + minWritableBytes > maxCapacity()
  - ensureWritableBytes
```
int ensureWritableBytes(int minWritableBytes,
                      boolean force)
```
    Tries to make sure the number of the writable bytes is equal to or greater than the specified value. Unlike ensureWritableBytes(int), this method does not raise an exception but returns a code.
    Parameters:
    minWritableBytes - the expected minimum number of writable bytes
    force - When writerIndex() + minWritableBytes > maxCapacity():
    
    true - the capacity of the buffer is expanded to maxCapacity()
    
    false - the capacity of the buffer is unchanged
    Returns:
    0 if the buffer has enough writable bytes, and its capacity is unchanged. 1 if the buffer does not have enough bytes, and its capacity is unchanged. 2 if the buffer has enough writable bytes, and its capacity has been increased. 3 if the buffer does not have enough bytes, but its capacity has been increased to its maximum.
  - getBoolean
```
boolean getBoolean(int index)
```
    Gets a boolean at the specified absolute (@code index) in this buffer. This method does not modify the readerIndex or writerIndex of this buffer.
    
    Throws:
    
    IndexOutOfBoundsException - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - 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,
            ByteBuf 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, ByteBuf, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes while getBytes(int, ByteBuf, 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,
            ByteBuf 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, ByteBuf, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes while getBytes(int, ByteBuf, 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,
            ByteBuf 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
  - setBoolean
```
void setBoolean(int index,
              boolean value)
```
    Sets the specified boolean 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
  - 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,
            ByteBuf 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, ByteBuf, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes while setBytes(int, ByteBuf, 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,
            ByteBuf 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, ByteBuf, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes while setBytes(int, ByteBuf, 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,
            ByteBuf 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 NULs to write to the buffer
    
    Throws:
    
    IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
  - readBoolean
```
boolean readBoolean()
```
    Gets a boolean at the current readerIndex and increases the readerIndex by 1 in this buffer.
    
    Throws:
    
    IndexOutOfBoundsException - if this.readableBytes is less than 1
  - 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
```
ByteBuf 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
  - readSlice
```
ByteBuf 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
  - readBytes
```
void readBytes(ByteBuf 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(ByteBuf, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes while readBytes(ByteBuf, int, int) does not.
    
    Throws:
    
    IndexOutOfBoundsException - if dst.writableBytes is greater than this.readableBytes
  - readBytes
```
void readBytes(ByteBuf 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(ByteBuf, int, int), except that this method increases the writerIndex of the destination by the number of the transferred bytes (= length) while readBytes(ByteBuf, int, int) does not.
    
    Throws:
    
    IndexOutOfBoundsException - if length is greater than this.readableBytes or if length is greater than dst.writableBytes
  - readBytes
```
void readBytes(ByteBuf 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
  - writeBoolean
```
void writeBoolean(boolean value)
```
    Sets the specified boolean at the current writerIndex and increases the writerIndex by 1 in this buffer.
    
    Throws:
    
    IndexOutOfBoundsException - if this.writableBytes is less than 1
  - 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(ByteBuf 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(ByteBuf, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes while writeBytes(ByteBuf, int, int) does not.
    
    Throws:
    
    IndexOutOfBoundsException - if src.readableBytes is greater than this.writableBytes
  - writeBytes
```
void writeBytes(ByteBuf 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(ByteBuf, int, int), except that this method increases the readerIndex of the source buffer by the number of the transferred bytes (= length) while writeBytes(ByteBuf, 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(ByteBuf 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 NULs 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,
          ByteBufIndexFinder 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(ByteBufIndexFinder 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,
              ByteBufIndexFinder 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,
              ByteBufIndexFinder 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
```
ByteBuf 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
```
ByteBuf 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
```
ByteBuf 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
```
ByteBuf 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
```
ByteBuf 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.
  - hasNioBuffer
```
boolean hasNioBuffer()
```
    Returns true if and only if nioBuffer() method will not fail.
  - nioBuffer
```
ByteBuffer nioBuffer()
```
    Exposes this buffer's readable bytes as an NIO ByteBuffer. The returned buffer shares the content with this buffer, while changing the position and limit of the returned NIO buffer does not affect the indexes and marks of this buffer. This method is identical to buf.asByteBuffer(buf.readerIndex(), buf.readableBytes()). This method does not modify readerIndex or writerIndex of this buffer. Please note that the returned NIO buffer will not see the changes of this buffer if this buffer is a dynamic buffer and it adjusted its capacity.
    
    Throws:
    
    UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
  - nioBuffer
```
ByteBuffer nioBuffer(int index,
                   int length)
```
    Exposes this buffer's sub-region as an NIO ByteBuffer. The returned buffer shares the content with this buffer, while changing the position and limit of the returned NIO buffer does not affect the indexes and marks of this buffer. This method does not modify readerIndex or writerIndex of this buffer. Please note that the returned NIO buffer will not see the changes of this buffer if this buffer is a dynamic buffer and it adjusted its capacity.
    
    Throws:
    
    UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
  - hasNioBuffers
```
boolean hasNioBuffers()
```
    Returns true if and only if nioBuffers() method will not fail.
  - nioBuffers
```
ByteBuffer[] nioBuffers()
```
    Exposes this buffer's readable bytes as an NIO ByteBuffer's. The returned buffer shares the content with this buffer, while changing the position and limit of the returned NIO buffer does not affect the indexes and marks of this buffer. This method does not modify readerIndex or writerIndex of this buffer. Please note that the returned NIO buffer will not see the changes of this buffer if this buffer is a dynamic buffer and it adjusted its capacity.
    
    Throws:
    
    UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
  - nioBuffers
```
ByteBuffer[] nioBuffers(int offset,
                      int length)
```
    Exposes this buffer's bytes as an NIO ByteBuffer's for the specified offset and length The returned buffer shares the content with this buffer, while changing the position and limit of the returned NIO buffer does not affect the indexes and marks of this buffer. This method does not modify readerIndex or writerIndex of this buffer. Please note that the returned NIO buffer will not see the changes of this buffer if this buffer is a dynamic buffer and it adjusted its capacity.
    
    Throws:
    
    UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
  - 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.
  - 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 ByteBuf type.
    Overrides:
    
    equals in class Object
  - compareTo
```
int compareTo(ByteBuf 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<ByteBuf>
  - 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
  - unsafe
```
ByteBuf.Unsafe unsafe()
```
    Returns an object that exposes unsafe expert-only operations which can lead to unspecified behavior.

Interface ByteBuf

Creation of a buffer

Random Access Indexing

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

Byte array

NIO Buffers

Strings

I/O Streams

Nested Class Summary

Method Summary

Methods inherited from interface io.netty.buffer.ChannelBuf

Method Detail

capacity

capacity

maxCapacity

order

order

isDirect

readerIndex

readerIndex

writerIndex

writerIndex

setIndex

readableBytes

writableBytes

readable

writable

clear

markReaderIndex

resetReaderIndex

markWriterIndex

resetWriterIndex

discardReadBytes

ensureWritableBytes

ensureWritableBytes

getBoolean

getByte

getUnsignedByte

getShort

getUnsignedShort

getMedium

getUnsignedMedium

getInt

getUnsignedInt

getLong

getChar

getFloat

getDouble

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

getBytes

setBoolean

setByte

setShort

setMedium

setInt

setLong

setChar

setFloat

setDouble

setBytes

setBytes

setBytes

setBytes

setBytes

setBytes

setBytes