java.lang.Object
- io.netty.buffer.ByteBuf

All Implemented Interfaces:

ByteBufConvertible, ReferenceCounted, java.lang.Comparable<ByteBuf>

Direct Known Subclasses:

AbstractByteBuf, EmptyByteBuf, SwappedByteBuf, WrappedByteBuf
```
public abstract class ByteBuf
extends java.lang.Object
implements ReferenceCounted, java.lang.Comparable<ByteBuf>, ByteBufConvertible
```
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 writerIndex 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.isReadable()) {
     System.out.println(buffer.readByte());
 }
 
```
Writable bytes
This segment is a undefined space which needs to be filled. Any operation whose name starts 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.maxWritableBytes() >= 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 ByteBuffer.clear().
```
  BEFORE clear()

      +-------------------+------------------+------------------+
      | discardable bytes |  readable bytes  |  writable bytes  |
      +-------------------+------------------+------------------+
      |                   |                  |                  |
      0      <=      readerIndex   <=   writerIndex    <=    capacity


  AFTER clear()

      +---------------------------------------------------------+
      |             writable bytes (got more space)             |
      +---------------------------------------------------------+
      |                                                         |
      0 = readerIndex = writerIndex            <=            capacity
 
```
Search operations
For simple single-byte searches, use indexOf(int, int, byte) and bytesBefore(int, int, byte). bytesBefore(byte) is especially useful when you deal with a NUL-terminated string. For complicated searches, use forEachByte(int, int, ByteProcessor) with a ByteProcessor implementation.
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 one of the following methods:
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.
Non-retained and retained derived buffers
Note that the duplicate(), slice(), slice(int, int) and readSlice(int) does NOT call retain() on the returned derived buffer, and thus its reference count will NOT be increased. If you need to create a derived buffer with increased reference count, consider using retainedDuplicate(), retainedSlice(), retainedSlice(int, int) and readRetainedSlice(int) which may return a buffer implementation that produces less garbage.
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 nioBufferCount().
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.

Constructor Summary

Constructors
Constructor Description

ByteBuf()

Method Summary

All Methods Instance Methods Abstract Methods Concrete Methods Deprecated Methods
Modifier and Type	Method	Description
`abstract ByteBufAllocator`	`alloc()`	Returns the `ByteBufAllocator` which created this buffer.
`abstract byte[]`	`array()`	Returns the backing byte array of this buffer.
`abstract int`	`arrayOffset()`	Returns the offset of the first byte within the backing byte array of this buffer.
`ByteBuf`	`asByteBuf()`	A `ByteBuf` can turn into itself.
`abstract ByteBuf`	`asReadOnly()`	Returns a read-only version of this buffer.
`abstract int`	`bytesBefore(byte value)`	Locates the first occurrence of the specified `value` in this buffer.
`abstract int`	`bytesBefore(int length, byte value)`	Locates the first occurrence of the specified `value` in this buffer.
`abstract int`	`bytesBefore(int index, int length, byte value)`	Locates the first occurrence of the specified `value` in this buffer.
`abstract int`	`capacity()`	Returns the number of bytes (octets) this buffer can contain.
`abstract ByteBuf`	`capacity(int newCapacity)`	Adjusts the capacity of this buffer.
`abstract ByteBuf`	`clear()`	Sets the `readerIndex` and `writerIndex` of this buffer to `0`.
`abstract int`	`compareTo(ByteBuf buffer)`	Compares the content of the specified buffer to the content of this buffer.
`abstract ByteBuf`	`copy()`	Returns a copy of this buffer's readable bytes.
`abstract ByteBuf`	`copy(int index, int length)`	Returns a copy of this buffer's sub-region.
`abstract ByteBuf`	`discardReadBytes()`	Discards the bytes between the 0th index and `readerIndex`.
`abstract ByteBuf`	`discardSomeReadBytes()`	Similar to `discardReadBytes()` except that this method might discard some, all, or none of read bytes depending on its internal implementation to reduce overall memory bandwidth consumption at the cost of potentially additional memory consumption.
`abstract ByteBuf`	`duplicate()`	Returns a buffer which shares the whole region of this buffer.
`abstract ByteBuf`	`ensureWritable(int minWritableBytes)`	Expands the buffer `capacity()` to make sure the number of writable bytes is equal to or greater than the specified value.
`abstract int`	`ensureWritable(int minWritableBytes, boolean force)`	Expands the buffer `capacity()` to make sure the number of writable bytes is equal to or greater than the specified value.
`abstract boolean`	`equals(java.lang.Object obj)`	Determines if the content of the specified buffer is identical to the content of this array.
`abstract int`	`forEachByte(int index, int length, ByteProcessor processor)`	Iterates over the specified area of this buffer with the specified `processor` in ascending order.
`abstract int`	`forEachByte(ByteProcessor processor)`	Iterates over the readable bytes of this buffer with the specified `processor` in ascending order.
`abstract int`	`forEachByteDesc(int index, int length, ByteProcessor processor)`	Iterates over the specified area of this buffer with the specified `processor` in descending order.
`abstract int`	`forEachByteDesc(ByteProcessor processor)`	Iterates over the readable bytes of this buffer with the specified `processor` in descending order.
`abstract boolean`	`getBoolean(int index)`	Gets a boolean at the specified absolute (@code index) in this buffer.
`abstract byte`	`getByte(int index)`	Gets a byte at the specified absolute `index` in this buffer.
`abstract ByteBuf`	`getBytes(int index, byte[] dst)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`abstract ByteBuf`	`getBytes(int index, byte[] dst, int dstIndex, int length)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`abstract ByteBuf`	`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.
`abstract ByteBuf`	`getBytes(int index, ByteBuf dst, int length)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`abstract ByteBuf`	`getBytes(int index, ByteBuf dst, int dstIndex, int length)`	Transfers this buffer's data to the specified destination starting at the specified absolute `index`.
`abstract ByteBuf`	`getBytes(int index, java.io.OutputStream out, int length)`	Transfers this buffer's data to the specified stream starting at the specified absolute `index`.
`abstract ByteBuf`	`getBytes(int index, java.nio.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.
`abstract int`	`getBytes(int index, java.nio.channels.FileChannel out, long position, int length)`	Transfers this buffer's data starting at the specified absolute `index` to the specified channel starting at the given file position.
`abstract int`	`getBytes(int index, java.nio.channels.GatheringByteChannel out, int length)`	Transfers this buffer's data to the specified channel starting at the specified absolute `index`.
`abstract char`	`getChar(int index)`	Gets a 2-byte UTF-16 character at the specified absolute `index` in this buffer.
`abstract java.lang.CharSequence`	`getCharSequence(int index, int length, java.nio.charset.Charset charset)`	Gets a `CharSequence` with the given length at the given index.
`abstract double`	`getDouble(int index)`	Gets a 64-bit floating point number at the specified absolute `index` in this buffer.
`double`	`getDoubleLE(int index)`	Gets a 64-bit floating point number at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract float`	`getFloat(int index)`	Gets a 32-bit floating point number at the specified absolute `index` in this buffer.
`float`	`getFloatLE(int index)`	Gets a 32-bit floating point number at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract int`	`getInt(int index)`	Gets a 32-bit integer at the specified absolute `index` in this buffer.
`abstract int`	`getIntLE(int index)`	Gets a 32-bit integer at the specified absolute `index` in this buffer with Little Endian Byte Order.
`abstract long`	`getLong(int index)`	Gets a 64-bit long integer at the specified absolute `index` in this buffer.
`abstract long`	`getLongLE(int index)`	Gets a 64-bit long integer at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract int`	`getMedium(int index)`	Gets a 24-bit medium integer at the specified absolute `index` in this buffer.
`abstract int`	`getMediumLE(int index)`	Gets a 24-bit medium integer at the specified absolute `index` in this buffer in the Little Endian Byte Order.
`abstract short`	`getShort(int index)`	Gets a 16-bit short integer at the specified absolute `index` in this buffer.
`abstract short`	`getShortLE(int index)`	Gets a 16-bit short integer at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract short`	`getUnsignedByte(int index)`	Gets an unsigned byte at the specified absolute `index` in this buffer.
`abstract long`	`getUnsignedInt(int index)`	Gets an unsigned 32-bit integer at the specified absolute `index` in this buffer.
`abstract long`	`getUnsignedIntLE(int index)`	Gets an unsigned 32-bit integer at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract int`	`getUnsignedMedium(int index)`	Gets an unsigned 24-bit medium integer at the specified absolute `index` in this buffer.
`abstract int`	`getUnsignedMediumLE(int index)`	Gets an unsigned 24-bit medium integer at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract int`	`getUnsignedShort(int index)`	Gets an unsigned 16-bit short integer at the specified absolute `index` in this buffer.
`abstract int`	`getUnsignedShortLE(int index)`	Gets an unsigned 16-bit short integer at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract boolean`	`hasArray()`	Returns `true` if and only if this buffer has a backing byte array.
`abstract int`	`hashCode()`	Returns a hash code which was calculated from the content of this buffer.
`abstract boolean`	`hasMemoryAddress()`	Returns `true` if and only if this buffer has a reference to the low-level memory address that points to the backing data.
`abstract int`	`indexOf(int fromIndex, int toIndex, byte value)`	Locates the first occurrence of the specified `value` in this buffer.
`abstract java.nio.ByteBuffer`	`internalNioBuffer(int index, int length)`	Internal use only: Exposes the internal NIO buffer.
`boolean`	`isContiguous()`	Returns `true` if this `ByteBuf` implementation is backed by a single memory region.
`abstract boolean`	`isDirect()`	Returns `true` if and only if this buffer is backed by an NIO direct buffer.
`abstract boolean`	`isReadable()`	Returns `true` if and only if `(this.writerIndex - this.readerIndex)` is greater than `0`.
`abstract boolean`	`isReadable(int size)`	Returns `true` if and only if this buffer contains equal to or more than the specified number of elements.
`abstract boolean`	`isReadOnly()`	Returns `true` if and only if this buffer is read-only.
`abstract boolean`	`isWritable()`	Returns `true` if and only if `(this.capacity - this.writerIndex)` is greater than `0`.
`abstract boolean`	`isWritable(int size)`	Returns `true` if and only if this buffer has enough room to allow writing the specified number of elements.
`abstract ByteBuf`	`markReaderIndex()`	Marks the current `readerIndex` in this buffer.
`abstract ByteBuf`	`markWriterIndex()`	Marks the current `writerIndex` in this buffer.
`abstract int`	`maxCapacity()`	Returns the maximum allowed capacity of this buffer.
`int`	`maxFastWritableBytes()`	Returns the maximum number of bytes which can be written for certain without involving an internal reallocation or data-copy.
`abstract int`	`maxWritableBytes()`	Returns the maximum possible number of writable bytes, which is equal to `(this.maxCapacity - this.writerIndex)`.
`abstract long`	`memoryAddress()`	Returns the low-level memory address that point to the first byte of ths backing data.
`abstract java.nio.ByteBuffer`	`nioBuffer()`	Exposes this buffer's readable bytes as an NIO `ByteBuffer`.
`abstract java.nio.ByteBuffer`	`nioBuffer(int index, int length)`	Exposes this buffer's sub-region as an NIO `ByteBuffer`.
`abstract int`	`nioBufferCount()`	Returns the maximum number of NIO `ByteBuffer`s that consist this buffer.
`abstract java.nio.ByteBuffer[]`	`nioBuffers()`	Exposes this buffer's readable bytes as an NIO `ByteBuffer`'s.
`abstract java.nio.ByteBuffer[]`	`nioBuffers(int index, int length)`	Exposes this buffer's bytes as an NIO `ByteBuffer`'s for the specified index and length The returned buffer either share or contains the copied content of this buffer, while changing the position and limit of the returned NIO buffer does not affect the indexes and marks of this buffer.
`abstract java.nio.ByteOrder`	`order()`	Deprecated. use the Little Endian accessors, e.g.
`abstract ByteBuf`	`order(java.nio.ByteOrder endianness)`	Deprecated. use the Little Endian accessors, e.g.
`abstract int`	`readableBytes()`	Returns the number of readable bytes which is equal to `(this.writerIndex - this.readerIndex)`.
`abstract boolean`	`readBoolean()`	Gets a boolean at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
`abstract byte`	`readByte()`	Gets a byte at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
`abstract ByteBuf`	`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`).
`abstract ByteBuf`	`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`).
`abstract 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`).
`abstract ByteBuf`	`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.
`abstract ByteBuf`	`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`).
`abstract ByteBuf`	`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`).
`abstract ByteBuf`	`readBytes(java.io.OutputStream out, int length)`	Transfers this buffer's data to the specified stream starting at the current `readerIndex`.
`abstract ByteBuf`	`readBytes(java.nio.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.
`abstract int`	`readBytes(java.nio.channels.FileChannel out, long position, int length)`	Transfers this buffer's data starting at the current `readerIndex` to the specified channel starting at the given file position.
`abstract int`	`readBytes(java.nio.channels.GatheringByteChannel out, int length)`	Transfers this buffer's data to the specified stream starting at the current `readerIndex`.
`abstract char`	`readChar()`	Gets a 2-byte UTF-16 character at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
`abstract java.lang.CharSequence`	`readCharSequence(int length, java.nio.charset.Charset charset)`	Gets a `CharSequence` with the given length at the current `readerIndex` and increases the `readerIndex` by the given length.
`abstract double`	`readDouble()`	Gets a 64-bit floating point number at the current `readerIndex` and increases the `readerIndex` by `8` in this buffer.
`double`	`readDoubleLE()`	Gets a 64-bit floating point number at the current `readerIndex` in Little Endian Byte Order and increases the `readerIndex` by `8` in this buffer.
`abstract int`	`readerIndex()`	Returns the `readerIndex` of this buffer.
`abstract ByteBuf`	`readerIndex(int readerIndex)`	Sets the `readerIndex` of this buffer.
`abstract float`	`readFloat()`	Gets a 32-bit floating point number at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
`float`	`readFloatLE()`	Gets a 32-bit floating point number at the current `readerIndex` in Little Endian Byte Order and increases the `readerIndex` by `4` in this buffer.
`abstract int`	`readInt()`	Gets a 32-bit integer at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
`abstract int`	`readIntLE()`	Gets a 32-bit integer at the current `readerIndex` in the Little Endian Byte Order and increases the `readerIndex` by `4` in this buffer.
`abstract long`	`readLong()`	Gets a 64-bit integer at the current `readerIndex` and increases the `readerIndex` by `8` in this buffer.
`abstract long`	`readLongLE()`	Gets a 64-bit integer at the current `readerIndex` in the Little Endian Byte Order and increases the `readerIndex` by `8` in this buffer.
`abstract int`	`readMedium()`	Gets a 24-bit medium integer at the current `readerIndex` and increases the `readerIndex` by `3` in this buffer.
`abstract int`	`readMediumLE()`	Gets a 24-bit medium integer at the current `readerIndex` in the Little Endian Byte Order and increases the `readerIndex` by `3` in this buffer.
`abstract ByteBuf`	`readRetainedSlice(int length)`	Returns a new retained slice of this buffer's sub-region starting at the current `readerIndex` and increases the `readerIndex` by the size of the new slice (= `length`).
`abstract short`	`readShort()`	Gets a 16-bit short integer at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
`abstract short`	`readShortLE()`	Gets a 16-bit short integer at the current `readerIndex` in the Little Endian Byte Order and increases the `readerIndex` by `2` in this buffer.
`abstract 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`).
`abstract short`	`readUnsignedByte()`	Gets an unsigned byte at the current `readerIndex` and increases the `readerIndex` by `1` in this buffer.
`abstract long`	`readUnsignedInt()`	Gets an unsigned 32-bit integer at the current `readerIndex` and increases the `readerIndex` by `4` in this buffer.
`abstract long`	`readUnsignedIntLE()`	Gets an unsigned 32-bit integer at the current `readerIndex` in the Little Endian Byte Order and increases the `readerIndex` by `4` in this buffer.
`abstract int`	`readUnsignedMedium()`	Gets an unsigned 24-bit medium integer at the current `readerIndex` and increases the `readerIndex` by `3` in this buffer.
`abstract int`	`readUnsignedMediumLE()`	Gets an unsigned 24-bit medium integer at the current `readerIndex` in the Little Endian Byte Order and increases the `readerIndex` by `3` in this buffer.
`abstract int`	`readUnsignedShort()`	Gets an unsigned 16-bit short integer at the current `readerIndex` and increases the `readerIndex` by `2` in this buffer.
`abstract int`	`readUnsignedShortLE()`	Gets an unsigned 16-bit short integer at the current `readerIndex` in the Little Endian Byte Order and increases the `readerIndex` by `2` in this buffer.
`abstract ByteBuf`	`resetReaderIndex()`	Repositions the current `readerIndex` to the marked `readerIndex` in this buffer.
`abstract ByteBuf`	`resetWriterIndex()`	Repositions the current `writerIndex` to the marked `writerIndex` in this buffer.
`abstract ByteBuf`	`retain()`	Increases the reference count by `1`.
`abstract ByteBuf`	`retain(int increment)`	Increases the reference count by the specified `increment`.
`abstract ByteBuf`	`retainedDuplicate()`	Returns a retained buffer which shares the whole region of this buffer.
`abstract ByteBuf`	`retainedSlice()`	Returns a retained slice of this buffer's readable bytes.
`abstract ByteBuf`	`retainedSlice(int index, int length)`	Returns a retained slice of this buffer's sub-region.
`abstract ByteBuf`	`setBoolean(int index, boolean value)`	Sets the specified boolean at the specified absolute `index` in this buffer.
`abstract ByteBuf`	`setByte(int index, int value)`	Sets the specified byte at the specified absolute `index` in this buffer.
`abstract ByteBuf`	`setBytes(int index, byte[] src)`	Transfers the specified source array's data to this buffer starting at the specified absolute `index`.
`abstract ByteBuf`	`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`.
`abstract ByteBuf`	`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.
`abstract ByteBuf`	`setBytes(int index, ByteBuf src, int length)`	Transfers the specified source buffer's data to this buffer starting at the specified absolute `index`.
`abstract ByteBuf`	`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`.
`abstract int`	`setBytes(int index, java.io.InputStream in, int length)`	Transfers the content of the specified source stream to this buffer starting at the specified absolute `index`.
`abstract ByteBuf`	`setBytes(int index, java.nio.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.
`abstract int`	`setBytes(int index, java.nio.channels.FileChannel in, long position, int length)`	Transfers the content of the specified source channel starting at the given file position to this buffer starting at the specified absolute `index`.
`abstract int`	`setBytes(int index, java.nio.channels.ScatteringByteChannel in, int length)`	Transfers the content of the specified source channel to this buffer starting at the specified absolute `index`.
`abstract ByteBuf`	`setChar(int index, int value)`	Sets the specified 2-byte UTF-16 character at the specified absolute `index` in this buffer.
`abstract int`	`setCharSequence(int index, java.lang.CharSequence sequence, java.nio.charset.Charset charset)`	Writes the specified `CharSequence` at the given `index`.
`abstract ByteBuf`	`setDouble(int index, double value)`	Sets the specified 64-bit floating-point number at the specified absolute `index` in this buffer.
`ByteBuf`	`setDoubleLE(int index, double value)`	Sets the specified 64-bit floating-point number at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract ByteBuf`	`setFloat(int index, float value)`	Sets the specified 32-bit floating-point number at the specified absolute `index` in this buffer.
`ByteBuf`	`setFloatLE(int index, float value)`	Sets the specified 32-bit floating-point number at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract ByteBuf`	`setIndex(int readerIndex, int writerIndex)`	Sets the `readerIndex` and `writerIndex` of this buffer in one shot.
`abstract ByteBuf`	`setInt(int index, int value)`	Sets the specified 32-bit integer at the specified absolute `index` in this buffer.
`abstract ByteBuf`	`setIntLE(int index, int value)`	Sets the specified 32-bit integer at the specified absolute `index` in this buffer with Little Endian byte order .
`abstract ByteBuf`	`setLong(int index, long value)`	Sets the specified 64-bit long integer at the specified absolute `index` in this buffer.
`abstract ByteBuf`	`setLongLE(int index, long value)`	Sets the specified 64-bit long integer at the specified absolute `index` in this buffer in Little Endian Byte Order.
`abstract ByteBuf`	`setMedium(int index, int value)`	Sets the specified 24-bit medium integer at the specified absolute `index` in this buffer.
`abstract ByteBuf`	`setMediumLE(int index, int value)`	Sets the specified 24-bit medium integer at the specified absolute `index` in this buffer in the Little Endian Byte Order.
`abstract ByteBuf`	`setShort(int index, int value)`	Sets the specified 16-bit short integer at the specified absolute `index` in this buffer.
`abstract ByteBuf`	`setShortLE(int index, int value)`	Sets the specified 16-bit short integer at the specified absolute `index` in this buffer with the Little Endian Byte Order.
`abstract ByteBuf`	`setZero(int index, int length)`	Fills this buffer with `NUL (0x00)` starting at the specified absolute `index`.
`abstract ByteBuf`	`skipBytes(int length)`	Increases the current `readerIndex` by the specified `length` in this buffer.
`abstract ByteBuf`	`slice()`	Returns a slice of this buffer's readable bytes.
`abstract ByteBuf`	`slice(int index, int length)`	Returns a slice of this buffer's sub-region.
`abstract java.lang.String`	`toString()`	Returns the string representation of this buffer.
`abstract java.lang.String`	`toString(int index, int length, java.nio.charset.Charset charset)`	Decodes this buffer's sub-region into a string with the specified character set.
`abstract java.lang.String`	`toString(java.nio.charset.Charset charset)`	Decodes this buffer's readable bytes into a string with the specified character set name.
`abstract ByteBuf`	`touch()`	Records the current access location of this object for debugging purposes.
`abstract ByteBuf`	`touch(java.lang.Object hint)`	Records the current access location of this object with an additional arbitrary information for debugging purposes.
`abstract ByteBuf`	`unwrap()`	Return the underlying buffer instance if this buffer is a wrapper of another buffer.
`abstract int`	`writableBytes()`	Returns the number of writable bytes which is equal to `(this.capacity - this.writerIndex)`.
`abstract ByteBuf`	`writeBoolean(boolean value)`	Sets the specified boolean at the current `writerIndex` and increases the `writerIndex` by `1` in this buffer.
`abstract ByteBuf`	`writeByte(int value)`	Sets the specified byte at the current `writerIndex` and increases the `writerIndex` by `1` in this buffer.
`abstract ByteBuf`	`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`).
`abstract ByteBuf`	`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`).
`abstract ByteBuf`	`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.
`abstract ByteBuf`	`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`).
`abstract ByteBuf`	`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`).
`abstract int`	`writeBytes(java.io.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.
`abstract ByteBuf`	`writeBytes(java.nio.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.
`abstract int`	`writeBytes(java.nio.channels.FileChannel in, long position, int length)`	Transfers the content of the specified channel starting at the given file position to this buffer starting at the current `writerIndex` and increases the `writerIndex` by the number of the transferred bytes.
`abstract int`	`writeBytes(java.nio.channels.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.
`abstract ByteBuf`	`writeChar(int value)`	Sets the specified 2-byte UTF-16 character at the current `writerIndex` and increases the `writerIndex` by `2` in this buffer.
`abstract int`	`writeCharSequence(java.lang.CharSequence sequence, java.nio.charset.Charset charset)`	Writes the specified `CharSequence` at the current `writerIndex` and increases the `writerIndex` by the written bytes.
`abstract ByteBuf`	`writeDouble(double value)`	Sets the specified 64-bit floating point number at the current `writerIndex` and increases the `writerIndex` by `8` in this buffer.
`ByteBuf`	`writeDoubleLE(double value)`	Sets the specified 64-bit floating point number at the current `writerIndex` in Little Endian Byte Order and increases the `writerIndex` by `8` in this buffer.
`abstract ByteBuf`	`writeFloat(float value)`	Sets the specified 32-bit floating point number at the current `writerIndex` and increases the `writerIndex` by `4` in this buffer.
`ByteBuf`	`writeFloatLE(float value)`	Sets the specified 32-bit floating point number at the current `writerIndex` in Little Endian Byte Order and increases the `writerIndex` by `4` in this buffer.
`abstract ByteBuf`	`writeInt(int value)`	Sets the specified 32-bit integer at the current `writerIndex` and increases the `writerIndex` by `4` in this buffer.
`abstract ByteBuf`	`writeIntLE(int value)`	Sets the specified 32-bit integer at the current `writerIndex` in the Little Endian Byte Order and increases the `writerIndex` by `4` in this buffer.
`abstract ByteBuf`	`writeLong(long value)`	Sets the specified 64-bit long integer at the current `writerIndex` and increases the `writerIndex` by `8` in this buffer.
`abstract ByteBuf`	`writeLongLE(long value)`	Sets the specified 64-bit long integer at the current `writerIndex` in the Little Endian Byte Order and increases the `writerIndex` by `8` in this buffer.
`abstract ByteBuf`	`writeMedium(int value)`	Sets the specified 24-bit medium integer at the current `writerIndex` and increases the `writerIndex` by `3` in this buffer.
`abstract ByteBuf`	`writeMediumLE(int value)`	Sets the specified 24-bit medium integer at the current `writerIndex` in the Little Endian Byte Order and increases the `writerIndex` by `3` in this buffer.
`abstract int`	`writerIndex()`	Returns the `writerIndex` of this buffer.
`abstract ByteBuf`	`writerIndex(int writerIndex)`	Sets the `writerIndex` of this buffer.
`abstract ByteBuf`	`writeShort(int value)`	Sets the specified 16-bit short integer at the current `writerIndex` and increases the `writerIndex` by `2` in this buffer.
`abstract ByteBuf`	`writeShortLE(int value)`	Sets the specified 16-bit short integer in the Little Endian Byte Order at the current `writerIndex` and increases the `writerIndex` by `2` in this buffer.
`abstract ByteBuf`	`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 class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface io.netty.util.ReferenceCounted
refCnt, release, release

- Constructor Detail
  - ByteBuf
```
public ByteBuf()
```
- Method Detail
  - capacity
```
public abstract int capacity()
```
    Returns the number of bytes (octets) this buffer can contain.
  - capacity
```
public abstract ByteBuf 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).
    
    Throws:
    
    java.lang.IllegalArgumentException - if the newCapacity is greater than maxCapacity()
  - maxCapacity
```
public abstract int maxCapacity()
```
    Returns the maximum allowed capacity of this buffer. This value provides an upper bound on capacity().
  - alloc
```
public abstract ByteBufAllocator alloc()
```
    Returns the ByteBufAllocator which created this buffer.
  - order
```
@Deprecated
public abstract java.nio.ByteOrder order()
```
    Deprecated.
    use the Little Endian accessors, e.g. getShortLE, getIntLE instead of creating a buffer with swapped endianness.
    
    Returns the endianness of this buffer.
  - order
```
@Deprecated
public abstract ByteBuf order(java.nio.ByteOrder endianness)
```
    Deprecated.
    use the Little Endian accessors, e.g. getShortLE, getIntLE instead of creating a buffer with swapped 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.
  - unwrap
```
public abstract ByteBuf unwrap()
```
    Return the underlying buffer instance if this buffer is a wrapper of another buffer.
    
    Returns:
    
    null if this buffer is not a wrapper
  - isDirect
```
public abstract boolean isDirect()
```
    Returns true if and only if this buffer is backed by an NIO direct buffer.
  - isReadOnly
```
public abstract boolean isReadOnly()
```
    Returns true if and only if this buffer is read-only.
  - asReadOnly
```
public abstract ByteBuf asReadOnly()
```
    Returns a read-only version of this buffer.
  - readerIndex
```
public abstract int readerIndex()
```
    Returns the readerIndex of this buffer.
  - readerIndex
```
public abstract ByteBuf readerIndex(int readerIndex)
```
    Sets the readerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified readerIndex is less than 0 or greater than this.writerIndex
  - writerIndex
```
public abstract int writerIndex()
```
    Returns the writerIndex of this buffer.
  - writerIndex
```
public abstract ByteBuf writerIndex(int writerIndex)
```
    Sets the writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified writerIndex is less than this.readerIndex or greater than this.capacity
  - setIndex
```
public abstract ByteBuf 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, this method 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:
    
    java.lang.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
```
public abstract int readableBytes()
```
    Returns the number of readable bytes which is equal to (this.writerIndex - this.readerIndex).
  - writableBytes
```
public abstract int writableBytes()
```
    Returns the number of writable bytes which is equal to (this.capacity - this.writerIndex).
  - maxWritableBytes
```
public abstract int maxWritableBytes()
```
    Returns the maximum possible number of writable bytes, which is equal to (this.maxCapacity - this.writerIndex).
  - maxFastWritableBytes
```
public int maxFastWritableBytes()
```
    Returns the maximum number of bytes which can be written for certain without involving an internal reallocation or data-copy. The returned value will be ≥ writableBytes() and ≤ maxWritableBytes().
  - isReadable
```
public abstract boolean isReadable()
```
    Returns true if and only if (this.writerIndex - this.readerIndex) is greater than 0.
  - isReadable
```
public abstract boolean isReadable(int size)
```
    Returns true if and only if this buffer contains equal to or more than the specified number of elements.
  - isWritable
```
public abstract boolean isWritable()
```
    Returns true if and only if (this.capacity - this.writerIndex) is greater than 0.
  - isWritable
```
public abstract boolean isWritable(int size)
```
    Returns true if and only if this buffer has enough room to allow writing the specified number of elements.
  - clear
```
public abstract ByteBuf 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
```
public abstract ByteBuf 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
```
public abstract ByteBuf resetReaderIndex()
```
    Repositions the current readerIndex to the marked readerIndex in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the current writerIndex is less than the marked readerIndex
  - markWriterIndex
```
public abstract ByteBuf 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
```
public abstract ByteBuf resetWriterIndex()
```
    Repositions the current writerIndex to the marked writerIndex in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the current readerIndex is greater than the marked writerIndex
  - discardReadBytes
```
public abstract ByteBuf 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.
  - discardSomeReadBytes
```
public abstract ByteBuf discardSomeReadBytes()
```
    Similar to discardReadBytes() except that this method might discard some, all, or none of read bytes depending on its internal implementation to reduce overall memory bandwidth consumption at the cost of potentially additional memory consumption.
  - ensureWritable
```
public abstract ByteBuf ensureWritable(int minWritableBytes)
```
    Expands the buffer capacity() to make sure the number of writable bytes is equal to or greater than the specified value. If there are enough writable bytes in this buffer, this method returns with no side effect.
    
    Parameters:
    
    minWritableBytes - the expected minimum number of writable bytes
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if writerIndex() + minWritableBytes > maxCapacity().
    
    See Also:
    
    capacity(int)
  - ensureWritable
```
public abstract int ensureWritable(int minWritableBytes,
                                   boolean force)
```
    Expands the buffer capacity() to make sure the number of writable bytes is equal to or greater than the specified value. Unlike ensureWritable(int), this method returns a status 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
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - getByte
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - getUnsignedByte
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - getShort
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - getShortLE
```
public abstract short getShortLE(int index)
```
    Gets a 16-bit short integer at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - getUnsignedShort
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - getUnsignedShortLE
```
public abstract int getUnsignedShortLE(int index)
```
    Gets an unsigned 16-bit short integer at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - getMedium
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 3 is greater than this.capacity
  - getMediumLE
```
public abstract int getMediumLE(int index)
```
    Gets a 24-bit medium integer at the specified absolute index in this buffer in the Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 3 is greater than this.capacity
  - getUnsignedMedium
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 3 is greater than this.capacity
  - getUnsignedMediumLE
```
public abstract int getUnsignedMediumLE(int index)
```
    Gets an unsigned 24-bit medium integer at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 3 is greater than this.capacity
  - getInt
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - getIntLE
```
public abstract int getIntLE(int index)
```
    Gets a 32-bit integer at the specified absolute index in this buffer with Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - getUnsignedInt
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - getUnsignedIntLE
```
public abstract long getUnsignedIntLE(int index)
```
    Gets an unsigned 32-bit integer at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - getLong
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - getLongLE
```
public abstract long getLongLE(int index)
```
    Gets a 64-bit long integer at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - getChar
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - getFloat
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - getFloatLE
```
public float getFloatLE(int index)
```
    Gets a 32-bit floating point number at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - getDouble
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - getDoubleLE
```
public double getDoubleLE(int index)
```
    Gets a 64-bit floating point number at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - getBytes
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + dst.writableBytes is greater than this.capacity
  - getBytes
```
public abstract ByteBuf 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:
    
    java.lang.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
```
public abstract ByteBuf 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:
    
    java.lang.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
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + dst.length is greater than this.capacity
  - getBytes
```
public abstract ByteBuf 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:
    
    java.lang.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
```
public abstract ByteBuf getBytes(int index,
                                 java.nio.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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + dst.remaining() is greater than this.capacity
  - getBytes
```
public abstract ByteBuf getBytes(int index,
                                 java.io.OutputStream out,
                                 int length)
                          throws java.io.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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    java.io.IOException - if the specified stream threw an exception during I/O
  - getBytes
```
public abstract int getBytes(int index,
                             java.nio.channels.GatheringByteChannel out,
                             int length)
                      throws java.io.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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - getBytes
```
public abstract int getBytes(int index,
                             java.nio.channels.FileChannel out,
                             long position,
                             int length)
                      throws java.io.IOException
```
    Transfers this buffer's data starting at the specified absolute index to the specified channel starting at the given file position. This method does not modify readerIndex or writerIndex of this buffer. This method does not modify the channel's position.
    
    Parameters:
    
    position - the file position at which the transfer is to begin
    
    length - the maximum number of bytes to transfer
    
    Returns:
    
    the actual number of bytes written out to the specified channel
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - getCharSequence
```
public abstract java.lang.CharSequence getCharSequence(int index,
                                                       int length,
                                                       java.nio.charset.Charset charset)
```
    Gets a CharSequence with the given length at the given index.
    
    Parameters:
    
    length - the length to read
    
    charset - that should be used
    
    Returns:
    
    the sequence
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
  - setBoolean
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - setByte
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 1 is greater than this.capacity
  - setShort
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - setShortLE
```
public abstract ByteBuf setShortLE(int index,
                                   int value)
```
    Sets the specified 16-bit short integer at the specified absolute index in this buffer with the Little Endian Byte Order. The 16 high-order bits of the specified value are ignored. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - setMedium
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 3 is greater than this.capacity
  - setMediumLE
```
public abstract ByteBuf setMediumLE(int index,
                                    int value)
```
    Sets the specified 24-bit medium integer at the specified absolute index in this buffer in the Little Endian Byte Order. 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 3 is greater than this.capacity
  - setInt
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - setIntLE
```
public abstract ByteBuf setIntLE(int index,
                                 int value)
```
    Sets the specified 32-bit integer at the specified absolute index in this buffer with Little Endian byte order . This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - setLong
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - setLongLE
```
public abstract ByteBuf setLongLE(int index,
                                  long value)
```
    Sets the specified 64-bit long integer at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - setChar
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 2 is greater than this.capacity
  - setFloat
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - setFloatLE
```
public ByteBuf setFloatLE(int index,
                          float value)
```
    Sets the specified 32-bit floating-point number at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 4 is greater than this.capacity
  - setDouble
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - setDoubleLE
```
public ByteBuf setDoubleLE(int index,
                           double value)
```
    Sets the specified 64-bit floating-point number at the specified absolute index in this buffer in Little Endian Byte Order. This method does not modify readerIndex or writerIndex of this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or index + 8 is greater than this.capacity
  - setBytes
```
public abstract ByteBuf 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 this buffer (i.e. this).
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + src.readableBytes is greater than this.capacity
  - setBytes
```
public abstract ByteBuf 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 this buffer (i.e. this).
    
    Parameters:
    
    length - the number of bytes to transfer
    
    Throws:
    
    java.lang.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
```
public abstract ByteBuf 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:
    
    java.lang.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
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + src.length is greater than this.capacity
  - setBytes
```
public abstract ByteBuf 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:
    
    java.lang.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
```
public abstract ByteBuf setBytes(int index,
                                 java.nio.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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + src.remaining() is greater than this.capacity
  - setBytes
```
public abstract int setBytes(int index,
                             java.io.InputStream in,
                             int length)
                      throws java.io.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 InputStream reached EOF.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    java.io.IOException - if the specified stream threw an exception during I/O
  - setBytes
```
public abstract int setBytes(int index,
                             java.nio.channels.ScatteringByteChannel in,
                             int length)
                      throws java.io.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 or it reached EOF.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - setBytes
```
public abstract int setBytes(int index,
                             java.nio.channels.FileChannel in,
                             long position,
                             int length)
                      throws java.io.IOException
```
    Transfers the content of the specified source channel starting at the given file position to this buffer starting at the specified absolute index. This method does not modify readerIndex or writerIndex of this buffer. This method does not modify the channel's position.
    
    Parameters:
    
    position - the file position at which the transfer is to begin
    
    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 or it reached EOF.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - setZero
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if the specified index is less than 0 or if index + length is greater than this.capacity
  - setCharSequence
```
public abstract int setCharSequence(int index,
                                    java.lang.CharSequence sequence,
                                    java.nio.charset.Charset charset)
```
    Writes the specified CharSequence at the given index. The writerIndex is not modified by this method.
    
    Parameters:
    
    index - on which the sequence should be written
    
    sequence - to write
    
    charset - that should be used.
    
    Returns:
    
    the written number of bytes.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the sequence at the given index would be out of bounds of the buffer capacity
  - readBoolean
```
public abstract boolean readBoolean()
```
    Gets a boolean at the current readerIndex and increases the readerIndex by 1 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 1
  - readByte
```
public abstract byte readByte()
```
    Gets a byte at the current readerIndex and increases the readerIndex by 1 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 1
  - readUnsignedByte
```
public abstract short readUnsignedByte()
```
    Gets an unsigned byte at the current readerIndex and increases the readerIndex by 1 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 1
  - readShort
```
public abstract short readShort()
```
    Gets a 16-bit short integer at the current readerIndex and increases the readerIndex by 2 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 2
  - readShortLE
```
public abstract short readShortLE()
```
    Gets a 16-bit short integer at the current readerIndex in the Little Endian Byte Order and increases the readerIndex by 2 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 2
  - readUnsignedShort
```
public abstract int readUnsignedShort()
```
    Gets an unsigned 16-bit short integer at the current readerIndex and increases the readerIndex by 2 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 2
  - readUnsignedShortLE
```
public abstract int readUnsignedShortLE()
```
    Gets an unsigned 16-bit short integer at the current readerIndex in the Little Endian Byte Order and increases the readerIndex by 2 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 2
  - readMedium
```
public abstract int readMedium()
```
    Gets a 24-bit medium integer at the current readerIndex and increases the readerIndex by 3 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 3
  - readMediumLE
```
public abstract int readMediumLE()
```
    Gets a 24-bit medium integer at the current readerIndex in the Little Endian Byte Order and increases the readerIndex by 3 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 3
  - readUnsignedMedium
```
public abstract int readUnsignedMedium()
```
    Gets an unsigned 24-bit medium integer at the current readerIndex and increases the readerIndex by 3 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 3
  - readUnsignedMediumLE
```
public abstract int readUnsignedMediumLE()
```
    Gets an unsigned 24-bit medium integer at the current readerIndex in the Little Endian Byte Order and increases the readerIndex by 3 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 3
  - readInt
```
public abstract int readInt()
```
    Gets a 32-bit integer at the current readerIndex and increases the readerIndex by 4 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 4
  - readIntLE
```
public abstract int readIntLE()
```
    Gets a 32-bit integer at the current readerIndex in the Little Endian Byte Order and increases the readerIndex by 4 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 4
  - readUnsignedInt
```
public abstract long readUnsignedInt()
```
    Gets an unsigned 32-bit integer at the current readerIndex and increases the readerIndex by 4 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 4
  - readUnsignedIntLE
```
public abstract long readUnsignedIntLE()
```
    Gets an unsigned 32-bit integer at the current readerIndex in the Little Endian Byte Order and increases the readerIndex by 4 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 4
  - readLong
```
public abstract long readLong()
```
    Gets a 64-bit integer at the current readerIndex and increases the readerIndex by 8 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 8
  - readLongLE
```
public abstract long readLongLE()
```
    Gets a 64-bit integer at the current readerIndex in the Little Endian Byte Order and increases the readerIndex by 8 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 8
  - readChar
```
public abstract char readChar()
```
    Gets a 2-byte UTF-16 character at the current readerIndex and increases the readerIndex by 2 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 2
  - readFloat
```
public abstract float readFloat()
```
    Gets a 32-bit floating point number at the current readerIndex and increases the readerIndex by 4 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 4
  - readFloatLE
```
public float readFloatLE()
```
    Gets a 32-bit floating point number at the current readerIndex in Little Endian Byte Order and increases the readerIndex by 4 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 4
  - readDouble
```
public abstract double readDouble()
```
    Gets a 64-bit floating point number at the current readerIndex and increases the readerIndex by 8 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 8
  - readDoubleLE
```
public double readDoubleLE()
```
    Gets a 64-bit floating point number at the current readerIndex in Little Endian Byte Order and increases the readerIndex by 8 in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if this.readableBytes is less than 8
  - readBytes
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
  - readSlice
```
public abstract 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).
    Also be aware that this method will NOT call retain() and so the reference count will NOT be increased.
    
    Parameters:
    
    length - the size of the new slice
    
    Returns:
    
    the newly created slice
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
  - readRetainedSlice
```
public abstract ByteBuf readRetainedSlice(int length)
```
    Returns a new retained slice of this buffer's sub-region starting at the current readerIndex and increases the readerIndex by the size of the new slice (= length).
    Note that this method returns a retained buffer unlike readSlice(int). This method behaves similarly to readSlice(...).retain() except that this method may return a buffer implementation that produces less garbage.
    
    Parameters:
    
    length - the size of the new slice
    
    Returns:
    
    the newly created slice
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
  - readBytes
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if dst.writableBytes is greater than this.readableBytes
  - readBytes
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes or if length is greater than dst.writableBytes
  - readBytes
```
public abstract ByteBuf 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:
    
    java.lang.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
```
public abstract ByteBuf 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:
    
    java.lang.IndexOutOfBoundsException - if dst.length is greater than this.readableBytes
  - readBytes
```
public abstract ByteBuf 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:
    
    java.lang.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
```
public abstract ByteBuf readBytes(java.nio.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:
    
    java.lang.IndexOutOfBoundsException - if dst.remaining() is greater than this.readableBytes
  - readBytes
```
public abstract ByteBuf readBytes(java.io.OutputStream out,
                                  int length)
                           throws java.io.IOException
```
    Transfers this buffer's data to the specified stream starting at the current readerIndex.
    
    Parameters:
    
    length - the number of bytes to transfer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
    
    java.io.IOException - if the specified stream threw an exception during I/O
  - readBytes
```
public abstract int readBytes(java.nio.channels.GatheringByteChannel out,
                              int length)
                       throws java.io.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:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - readCharSequence
```
public abstract java.lang.CharSequence readCharSequence(int length,
                                                        java.nio.charset.Charset charset)
```
    Gets a CharSequence with the given length at the current readerIndex and increases the readerIndex by the given length.
    
    Parameters:
    
    length - the length to read
    
    charset - that should be used
    
    Returns:
    
    the sequence
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
  - readBytes
```
public abstract int readBytes(java.nio.channels.FileChannel out,
                              long position,
                              int length)
                       throws java.io.IOException
```
    Transfers this buffer's data starting at the current readerIndex to the specified channel starting at the given file position. This method does not modify the channel's position.
    
    Parameters:
    
    position - the file position at which the transfer is to begin
    
    length - the maximum number of bytes to transfer
    
    Returns:
    
    the actual number of bytes written out to the specified channel
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - skipBytes
```
public abstract ByteBuf skipBytes(int length)
```
    Increases the current readerIndex by the specified length in this buffer.
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
  - writeBoolean
```
public abstract ByteBuf writeBoolean(boolean value)
```
    Sets the specified boolean at the current writerIndex and increases the writerIndex by 1 in this buffer. If this.writableBytes is less than 1, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeByte
```
public abstract ByteBuf 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. If this.writableBytes is less than 1, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeShort
```
public abstract ByteBuf 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. If this.writableBytes is less than 2, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeShortLE
```
public abstract ByteBuf writeShortLE(int value)
```
    Sets the specified 16-bit short integer in the Little Endian Byte Order at the current writerIndex and increases the writerIndex by 2 in this buffer. The 16 high-order bits of the specified value are ignored. If this.writableBytes is less than 2, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeMedium
```
public abstract ByteBuf writeMedium(int value)
```
    Sets the specified 24-bit medium integer at the current writerIndex and increases the writerIndex by 3 in this buffer. If this.writableBytes is less than 3, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeMediumLE
```
public abstract ByteBuf writeMediumLE(int value)
```
    Sets the specified 24-bit medium integer at the current writerIndex in the Little Endian Byte Order and increases the writerIndex by 3 in this buffer. If this.writableBytes is less than 3, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeInt
```
public abstract ByteBuf writeInt(int value)
```
    Sets the specified 32-bit integer at the current writerIndex and increases the writerIndex by 4 in this buffer. If this.writableBytes is less than 4, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeIntLE
```
public abstract ByteBuf writeIntLE(int value)
```
    Sets the specified 32-bit integer at the current writerIndex in the Little Endian Byte Order and increases the writerIndex by 4 in this buffer. If this.writableBytes is less than 4, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeLong
```
public abstract ByteBuf writeLong(long value)
```
    Sets the specified 64-bit long integer at the current writerIndex and increases the writerIndex by 8 in this buffer. If this.writableBytes is less than 8, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeLongLE
```
public abstract ByteBuf writeLongLE(long value)
```
    Sets the specified 64-bit long integer at the current writerIndex in the Little Endian Byte Order and increases the writerIndex by 8 in this buffer. If this.writableBytes is less than 8, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeChar
```
public abstract ByteBuf 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. If this.writableBytes is less than 2, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeFloat
```
public abstract ByteBuf writeFloat(float value)
```
    Sets the specified 32-bit floating point number at the current writerIndex and increases the writerIndex by 4 in this buffer. If this.writableBytes is less than 4, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeFloatLE
```
public ByteBuf writeFloatLE(float value)
```
    Sets the specified 32-bit floating point number at the current writerIndex in Little Endian Byte Order and increases the writerIndex by 4 in this buffer. If this.writableBytes is less than 4, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeDouble
```
public abstract ByteBuf writeDouble(double value)
```
    Sets the specified 64-bit floating point number at the current writerIndex and increases the writerIndex by 8 in this buffer. If this.writableBytes is less than 8, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeDoubleLE
```
public ByteBuf writeDoubleLE(double value)
```
    Sets the specified 64-bit floating point number at the current writerIndex in Little Endian Byte Order and increases the writerIndex by 8 in this buffer. If this.writableBytes is less than 8, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeBytes
```
public abstract ByteBuf 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. If this.writableBytes is less than src.readableBytes, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeBytes
```
public abstract ByteBuf 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. If this.writableBytes is less than length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    Parameters:
    
    length - the number of bytes to transfer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if length is greater then src.readableBytes
  - writeBytes
```
public abstract ByteBuf 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). If this.writableBytes is less than length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    Parameters:
    
    srcIndex - the first index of the source
    
    length - the number of bytes to transfer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified srcIndex is less than 0, or if srcIndex + length is greater than src.capacity
  - writeBytes
```
public abstract ByteBuf 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). If this.writableBytes is less than src.length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeBytes
```
public abstract ByteBuf 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). If this.writableBytes is less than length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    Parameters:
    
    srcIndex - the first index of the source
    
    length - the number of bytes to transfer
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - if the specified srcIndex is less than 0, or if srcIndex + length is greater than src.length
  - writeBytes
```
public abstract ByteBuf writeBytes(java.nio.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. If this.writableBytes is less than src.remaining(), ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
  - writeBytes
```
public abstract int writeBytes(java.io.InputStream in,
                               int length)
                        throws java.io.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. If this.writableBytes is less than length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    Parameters:
    
    length - the number of bytes to transfer
    
    Returns:
    
    the actual number of bytes read in from the specified channel. -1 if the specified InputStream reached EOF.
    
    Throws:
    
    java.io.IOException - if the specified stream threw an exception during I/O
  - writeBytes
```
public abstract int writeBytes(java.nio.channels.ScatteringByteChannel in,
                               int length)
                        throws java.io.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. If this.writableBytes is less than length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    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 or it reached EOF.
    
    Throws:
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - writeBytes
```
public abstract int writeBytes(java.nio.channels.FileChannel in,
                               long position,
                               int length)
                        throws java.io.IOException
```
    Transfers the content of the specified channel starting at the given file position to this buffer starting at the current writerIndex and increases the writerIndex by the number of the transferred bytes. This method does not modify the channel's position. If this.writableBytes is less than length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    Parameters:
    
    position - the file position at which the transfer is to begin
    
    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 or it reached EOF.
    
    Throws:
    
    java.io.IOException - if the specified channel threw an exception during I/O
  - writeZero
```
public abstract ByteBuf writeZero(int length)
```
    Fills this buffer with NUL (0x00) starting at the current writerIndex and increases the writerIndex by the specified length. If this.writableBytes is less than length, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    Parameters:
    
    length - the number of NULs to write to the buffer
  - writeCharSequence
```
public abstract int writeCharSequence(java.lang.CharSequence sequence,
                                      java.nio.charset.Charset charset)
```
    Writes the specified CharSequence at the current writerIndex and increases the writerIndex by the written bytes. in this buffer. If this.writableBytes is not large enough to write the whole sequence, ensureWritable(int) will be called in an attempt to expand capacity to accommodate.
    
    Parameters:
    
    sequence - to write
    
    charset - that should be used
    
    Returns:
    
    the written number of bytes
  - indexOf
```
public abstract 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 from fromIndex (exclusive) down to toIndex (inclusive).
    Note that the lower index is always included and higher always excluded.
    This method does not modify readerIndex or writerIndex of this buffer.
    
    Returns:
    
    the absolute index of the first occurrence if found. -1 otherwise.
  - bytesBefore
```
public abstract 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
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if length is greater than this.readableBytes
  - bytesBefore
```
public abstract 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:
    
    java.lang.IndexOutOfBoundsException - if index + length is greater than this.capacity
  - forEachByte
```
public abstract int forEachByte(ByteProcessor processor)
```
    Iterates over the readable bytes of this buffer with the specified processor in ascending order.
    
    Returns:
    
    -1 if the processor iterated to or beyond the end of the readable bytes. The last-visited index If the ByteProcessor.process(byte) returned false.
  - forEachByte
```
public abstract int forEachByte(int index,
                                int length,
                                ByteProcessor processor)
```
    Iterates over the specified area of this buffer with the specified processor in ascending order. (i.e. index, (index + 1), .. (index + length - 1))
    
    Returns:
    
    -1 if the processor iterated to or beyond the end of the specified area. The last-visited index If the ByteProcessor.process(byte) returned false.
  - forEachByteDesc
```
public abstract int forEachByteDesc(ByteProcessor processor)
```
    Iterates over the readable bytes of this buffer with the specified processor in descending order.
    
    Returns:
    
    -1 if the processor iterated to or beyond the beginning of the readable bytes. The last-visited index If the ByteProcessor.process(byte) returned false.
  - forEachByteDesc
```
public abstract int forEachByteDesc(int index,
                                    int length,
                                    ByteProcessor processor)
```
    Iterates over the specified area of this buffer with the specified processor in descending order. (i.e. (index + length - 1), (index + length - 2), ... index)
    
    Returns:
    
    -1 if the processor iterated to or beyond the beginning of the specified area. The last-visited index If the ByteProcessor.process(byte) returned false.
  - copy
```
public abstract 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
```
public abstract 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
```
public abstract 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.
    Also be aware that this method will NOT call retain() and so the reference count will NOT be increased.
  - retainedSlice
```
public abstract ByteBuf retainedSlice()
```
    Returns a retained 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.
    Note that this method returns a retained buffer unlike slice(). This method behaves similarly to slice().retain() except that this method may return a buffer implementation that produces less garbage.
  - slice
```
public abstract 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.
    Also be aware that this method will NOT call retain() and so the reference count will NOT be increased.
  - retainedSlice
```
public abstract ByteBuf retainedSlice(int index,
                                      int length)
```
    Returns a retained 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.
    Note that this method returns a retained buffer unlike slice(int, int). This method behaves similarly to slice(...).retain() except that this method may return a buffer implementation that produces less garbage.
  - duplicate
```
public abstract 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 does not modify readerIndex or writerIndex of this buffer.
    The reader and writer marks will not be duplicated. Also be aware that this method will NOT call retain() and so the reference count will NOT be increased.
    
    Returns:
    
    A buffer whose readable content is equivalent to the buffer returned by slice(). However this buffer will share the capacity of the underlying buffer, and therefore allows access to all of the underlying content if necessary.
  - retainedDuplicate
```
public abstract ByteBuf retainedDuplicate()
```
    Returns a retained 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.
    Note that this method returns a retained buffer unlike slice(int, int). This method behaves similarly to duplicate().retain() except that this method may return a buffer implementation that produces less garbage.
  - nioBufferCount
```
public abstract int nioBufferCount()
```
    Returns the maximum number of NIO ByteBuffers that consist this buffer. Note that nioBuffers() or nioBuffers(int, int) might return a less number of ByteBuffers.
    
    Returns:
    
    -1 if this buffer has no underlying ByteBuffer. the number of the underlying ByteBuffers if this buffer has at least one underlying ByteBuffer. Note that this method does not return 0 to avoid confusion.
    
    See Also:
    
    nioBuffer(), nioBuffer(int, int), nioBuffers(), nioBuffers(int, int)
  - nioBuffer
```
public abstract java.nio.ByteBuffer nioBuffer()
```
    Exposes this buffer's readable bytes as an NIO ByteBuffer. The returned buffer either share or contains the copied content of 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.nioBuffer(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:
    
    java.lang.UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
    
    See Also:
    
    nioBufferCount(), nioBuffers(), nioBuffers(int, int)
  - nioBuffer
```
public abstract java.nio.ByteBuffer nioBuffer(int index,
                                              int length)
```
    Exposes this buffer's sub-region as an NIO ByteBuffer. The returned buffer either share or contains the copied content of 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:
    
    java.lang.UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
    
    See Also:
    
    nioBufferCount(), nioBuffers(), nioBuffers(int, int)
  - internalNioBuffer
```
public abstract java.nio.ByteBuffer internalNioBuffer(int index,
                                                      int length)
```
    Internal use only: Exposes the internal NIO buffer.
  - nioBuffers
```
public abstract java.nio.ByteBuffer[] nioBuffers()
```
    Exposes this buffer's readable bytes as an NIO ByteBuffer's. The returned buffer either share or contains the copied content of 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:
    
    java.lang.UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
    
    See Also:
    
    nioBufferCount(), nioBuffer(), nioBuffer(int, int)
  - nioBuffers
```
public abstract java.nio.ByteBuffer[] nioBuffers(int index,
                                                 int length)
```
    Exposes this buffer's bytes as an NIO ByteBuffer's for the specified index and length The returned buffer either share or contains the copied content of 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:
    
    java.lang.UnsupportedOperationException - if this buffer cannot create a ByteBuffer that shares the content with itself
    
    See Also:
    
    nioBufferCount(), nioBuffer(), nioBuffer(int, int)
  - hasArray
```
public abstract 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
```
public abstract byte[] array()
```
    Returns the backing byte array of this buffer.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if there no accessible backing byte array
  - arrayOffset
```
public abstract int arrayOffset()
```
    Returns the offset of the first byte within the backing byte array of this buffer.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if there no accessible backing byte array
  - hasMemoryAddress
```
public abstract boolean hasMemoryAddress()
```
    Returns true if and only if this buffer has a reference to the low-level memory address that points to the backing data.
  - memoryAddress
```
public abstract long memoryAddress()
```
    Returns the low-level memory address that point to the first byte of ths backing data.
    
    Throws:
    
    java.lang.UnsupportedOperationException - if this buffer does not support accessing the low-level memory address
  - isContiguous
```
public boolean isContiguous()
```
    Returns true if this ByteBuf implementation is backed by a single memory region. Composite buffer implementations must return false even if they currently hold ≤ 1 components. For buffers that return true, it's guaranteed that a successful call to discardReadBytes() will increase the value of maxFastWritableBytes() by the current readerIndex.
    This method will return false by default, and a false return value does not necessarily mean that the implementation is composite or that it is not backed by a single memory region.
  - asByteBuf
```
public ByteBuf asByteBuf()
```
    A ByteBuf can turn into itself.
    
    Specified by:
    
    asByteBuf in interface ByteBufConvertible
    
    Returns:
    
    This ByteBuf instance.
  - toString
```
public abstract java.lang.String toString(java.nio.charset.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:
    
    java.nio.charset.UnsupportedCharsetException - if the specified character set name is not supported by the current VM
  - toString
```
public abstract java.lang.String toString(int index,
                                          int length,
                                          java.nio.charset.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
```
public abstract 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 java.lang.Object
  - equals
```
public abstract boolean equals(java.lang.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 java.lang.Object
  - compareTo
```
public abstract 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 java.lang.Comparable<ByteBuf>
  - toString
```
public abstract java.lang.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 java.lang.Object
  - retain
```
public abstract ByteBuf retain(int increment)
```
    Description copied from interface: ReferenceCounted
    
    Increases the reference count by the specified increment.
    
    Specified by:
    
    retain in interface ReferenceCounted
  - retain
```
public abstract ByteBuf retain()
```
    Description copied from interface: ReferenceCounted
    
    Increases the reference count by 1.
    
    Specified by:
    
    retain in interface ReferenceCounted
  - touch
```
public abstract ByteBuf touch()
```
    Description copied from interface: ReferenceCounted
    
    Records the current access location of this object for debugging purposes. If this object is determined to be leaked, the information recorded by this operation will be provided to you via ResourceLeakDetector. This method is a shortcut to touch(null).
    
    Specified by:
    
    touch in interface ReferenceCounted
  - touch
```
public abstract ByteBuf touch(java.lang.Object hint)
```
    Description copied from interface: ReferenceCounted
    
    Records the current access location of this object with an additional arbitrary information for debugging purposes. If this object is determined to be leaked, the information recorded by this operation will be provided to you via ResourceLeakDetector.
    
    Specified by:
    
    touch in interface ReferenceCounted

Class 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

Non-retained and retained derived buffers

Conversion to existing JDK types

Byte array

NIO Buffers

Strings

I/O Streams

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface io.netty.util.ReferenceCounted

Constructor Detail

ByteBuf

Method Detail

capacity

capacity

maxCapacity

alloc

order

order

unwrap

isDirect

isReadOnly

asReadOnly

readerIndex

readerIndex

writerIndex

writerIndex

setIndex

readableBytes

writableBytes

maxWritableBytes

maxFastWritableBytes

isReadable

isReadable

isWritable

isWritable

clear

markReaderIndex

resetReaderIndex

markWriterIndex

resetWriterIndex

discardReadBytes

discardSomeReadBytes

ensureWritable

ensureWritable

getBoolean

getByte

getUnsignedByte

getShort

getShortLE

getUnsignedShort

getUnsignedShortLE

getMedium

getMediumLE

getUnsignedMedium

getUnsignedMediumLE

getInt

getIntLE

getUnsignedInt

getUnsignedIntLE

getLong

getLongLE

getChar

getFloat

getFloatLE

getDouble

getDoubleLE

getBytes

getBytes