Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

## org.apache.mina.common
Class ByteBuffer

    java.lang.Object
      org.apache.mina.common.ByteBuffer

All Implemented Interfaces:
  Comparable<ByteBuffer>

Direct Known Subclasses:
  ByteBufferProxy

    public abstract class ByteBuffer

extends Object
implements Comparable<ByteBuffer>

A byte buffer used by MINA applications.

This is a replacement for `ByteBuffer`. Please refer to `ByteBuffer` and `Buffer` documentation for usage. MINA does not use NIO `ByteBuffer` directly for two reasons:

- It doesn't provide useful getters and putters such as `fill`, `get/putString`, and `get/putAsciiInt()` enough.
- It is hard to distinguish if the buffer is created from MINA buffer pool or not. MINA have to return used buffers back to pool.
- It is difficult to write variable-length data due to its fixed capacity

## Allocation

You can get a heap buffer from buffer pool:

     ByteBuffer buf = ByteBuffer.allocate(1024, false);

you can also get a direct buffer from buffer pool:

     ByteBuffer buf = ByteBuffer.allocate(1024, true);

or you can let MINA choose:

     ByteBuffer buf = ByteBuffer.allocate(1024);

## Acquire/Release

Please note that you never need to release the allocated buffer because MINA will release it automatically when:

- You pass the buffer by calling `IoSession.write(Object)`.
- You pass the buffer by calling `IoFilter.NextFilter.filterWrite(IoSession,IoFilter.WriteRequest)`.
- You pass the buffer by calling `ProtocolEncoderOutput.write(ByteBuffer)`.

And, you don't need to release any `ByteBuffer` which is passed as a parameter of `IoHandler.messageReceived(IoSession, Object)` method. They are released automatically when the method returns.

You have to release buffers manually by calling `release()` when:

- You allocated a buffer, but didn't pass the buffer to any of two methods above.
- You called `acquire()` to prevent the buffer from being released.

## Wrapping existing NIO buffers and arrays

This class provides a few `wrap(...)` methods that wraps any NIO buffers and byte arrays. Wrapped MINA buffers are not returned to the buffer pool by default to prevent unexpected memory leakage by default. In case you want to make it pooled, you can call `setPooled(boolean)` with `true` flag to enable pooling.

## AutoExpand

Writing variable-length data using NIO `ByteBuffers` is not really easy, and it is because its size is fixed. MINA `ByteBuffer` introduces `autoExpand` property. If `autoExpand` property is true, you never get `BufferOverflowException` or `IndexOutOfBoundsException` (except when index is negative). It automatically expands its capacity and limit value. For example:

     String greeting = messageBundle.getMessage( "hello" );
     ByteBuffer buf = ByteBuffer.allocate( 16 );
     // Turn on autoExpand (it is off by default)
     buf.setAutoExpand( true );
     buf.putString( greeting, utf8encoder );

NIO `ByteBuffer` is reallocated by MINA `ByteBuffer` behind the scene if the encoded data is larger than 16 bytes. Its capacity and its limit will increase to the last position the string is written.

## Derived Buffers

Derived buffers are the buffers which were created by `duplicate()`, `slice()`, or `asReadOnlyBuffer()`. They are useful especially when you broadcast the same messages to multiple `IoSession`s. Please note that the derived buffers are neither pooled nor auto-expandable. Trying to expand a derived buffer will raise `IllegalStateException`.

## Changing Buffer Allocation and Management Policy

MINA provides a `ByteBufferAllocator` interface to let you override the default buffer management behavior. There are two allocators provided out-of-the-box:

- `PooledByteBufferAllocator` (Default)
- `SimpleByteBufferAllocator`

You can change the allocator by calling `setAllocator(ByteBufferAllocator)`.

Version:
  $Rev: 637706 $, $Date: 2008-03-17 12:18:43 +0900 (Mon, 17 Mar 2008) $
Author:
  The Apache Directory Project (mina-dev@directory.apache.org)
See Also:
  `ByteBufferAllocator`

Constructor Summary
`protected` | `ByteBuffer()`

Method Summary
`abstract void` | `acquire()` Increases the internal reference count of this buffer to defer automatic release.
`static ByteBuffer` | `allocate(int capacity)` Returns the direct or heap buffer which is capable of the specified size.
`static ByteBuffer` | `allocate(int capacity, boolean direct)` Returns the buffer which is capable of the specified size.
`abstract byte[]` | `array()`
`abstract int` | `arrayOffset()`
`abstract CharBuffer` | `asCharBuffer()`
`abstract DoubleBuffer` | `asDoubleBuffer()`
`abstract FloatBuffer` | `asFloatBuffer()`
`InputStream` | `asInputStream()` Returns an `InputStream` that reads the data from this buffer.
`abstract IntBuffer` | `asIntBuffer()`
`abstract LongBuffer` | `asLongBuffer()`
`OutputStream` | `asOutputStream()` Returns an `OutputStream` that appends the data into this buffer.
`abstract ByteBuffer` | `asReadOnlyBuffer()`
`abstract ShortBuffer` | `asShortBuffer()`
`protected ByteBuffer` | `autoExpand(int expectedRemaining)` This method forwards the call to `expand(int)` only when `autoExpand` property is `true`.
`protected ByteBuffer` | `autoExpand(int pos, int expectedRemaining)` This method forwards the call to `expand(int)` only when `autoExpand` property is `true`.
`abstract ByteBuffer` | `buf()` Returns the underlying NIO buffer instance.
`abstract int` | `capacity()`
`abstract ByteBuffer` | `capacity(int newCapacity)` Changes the capacity of this buffer.
`abstract ByteBuffer` | `clear()`
`abstract ByteBuffer` | `compact()`
`int` | `compareTo(ByteBuffer that)`
`abstract ByteBuffer` | `duplicate()`
`boolean` | `equals(Object o)`
`ByteBuffer` | `expand(int expectedRemaining)` Changes the capacity and limit of this buffer so this buffer get the specified `expectedRemaining` room from the current position.
`abstract ByteBuffer` | `expand(int pos, int expectedRemaining)` Changes the capacity and limit of this buffer so this buffer get the specified `expectedRemaining` room from the specified `pos`.
`ByteBuffer` | `fill(byte value, int size)` Fills this buffer with the specified value.
`ByteBuffer` | `fill(int size)` Fills this buffer with `NUL (0x00)`.
`ByteBuffer` | `fillAndReset(byte value, int size)` Fills this buffer with the specified value.
`ByteBuffer` | `fillAndReset(int size)` Fills this buffer with `NUL (0x00)`.
`abstract ByteBuffer` | `flip()`
`abstract byte` | `get()`
`ByteBuffer` | `get(byte[] dst)`
`abstract ByteBuffer` | `get(byte[] dst, int offset, int length)`
`abstract byte` | `get(int index)`
`static ByteBufferAllocator` | `getAllocator()` Returns the current allocator which manages the allocated buffers.
`abstract char` | `getChar()`
`abstract char` | `getChar(int index)`
`abstract double` | `getDouble()`
`abstract double` | `getDouble(int index)`
`abstract float` | `getFloat()`
`abstract float` | `getFloat(int index)`
`String` | `getHexDump()` Returns hexdump of this buffer.
`abstract int` | `getInt()`
`abstract int` | `getInt(int index)`
`abstract long` | `getLong()`
`abstract long` | `getLong(int index)`
`Object` | `getObject()` Reads a Java object from the buffer using the context `ClassLoader` of the current thread.
`Object` | `getObject(ClassLoader classLoader)` Reads a Java object from the buffer using the specified `classLoader`.
`String` | `getPrefixedString(CharsetDecoder decoder)` Reads a string which has a 16-bit length field before the actual encoded string, using the specified `decoder` and returns it.
`String` | `getPrefixedString(int prefixLength, CharsetDecoder decoder)` Reads a string which has a length field before the actual encoded string, using the specified `decoder` and returns it.
`abstract short` | `getShort()`
`abstract short` | `getShort(int index)`
`String` | `getString(CharsetDecoder decoder)` Reads a `NUL`-terminated string from this buffer using the specified `decoder` and returns it.
`String` | `getString(int fieldSize, CharsetDecoder decoder)` Reads a `NUL`-terminated string from this buffer using the specified `decoder` and returns it.
`short` | `getUnsigned()` Reads one unsigned byte as a short integer.
`short` | `getUnsigned(int index)` Reads one byte as an unsigned short integer.
`long` | `getUnsignedInt()` Reads four bytes unsigned integer.
`long` | `getUnsignedInt(int index)` Reads four bytes unsigned integer.
`int` | `getUnsignedShort()` Reads two bytes unsigned integer.
`int` | `getUnsignedShort(int index)` Reads two bytes unsigned integer.
`int` | `hashCode()`
`boolean` | `hasRemaining()`
`abstract boolean` | `isAutoExpand()` Returns `true` if and only if `autoExpand` is turned on.
`abstract boolean` | `isDirect()`
`abstract boolean` | `isPooled()` Returns `true` if and only if this buffer is returned back to the buffer pool when released.
`abstract boolean` | `isReadOnly()`
`static boolean` | `isUseDirectBuffers()`
`abstract int` | `limit()`
`abstract ByteBuffer` | `limit(int newLimit)`
`abstract ByteBuffer` | `mark()`
`abstract int` | `markValue()` Returns the position of the current mark.
`abstract ByteOrder` | `order()`
`abstract ByteBuffer` | `order(ByteOrder bo)`
`abstract int` | `position()`
`abstract ByteBuffer` | `position(int newPosition)`
`boolean` | `prefixedDataAvailable(int prefixLength)` Returns `true` if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field.
`boolean` | `prefixedDataAvailable(int prefixLength, int maxDataLength)` Returns `true` if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field.
`abstract ByteBuffer` | `put(byte b)`
`ByteBuffer` | `put(byte[] src)`
`abstract ByteBuffer` | `put(byte[] src, int offset, int length)`
`abstract ByteBuffer` | `put(ByteBuffer src)` Writes the content of the specified `src` into this buffer.
`ByteBuffer` | `put(ByteBuffer src)` Writes the content of the specified `src` into this buffer.
`abstract ByteBuffer` | `put(int index, byte b)`
`abstract ByteBuffer` | `putChar(char value)`
`abstract ByteBuffer` | `putChar(int index, char value)`
`abstract ByteBuffer` | `putDouble(double value)`
`abstract ByteBuffer` | `putDouble(int index, double value)`
`abstract ByteBuffer` | `putFloat(float value)`
`abstract ByteBuffer` | `putFloat(int index, float value)`
`abstract ByteBuffer` | `putInt(int value)`
`abstract ByteBuffer` | `putInt(int index, int value)`
`abstract ByteBuffer` | `putLong(int index, long value)`
`abstract ByteBuffer` | `putLong(long value)`
`ByteBuffer` | `putObject(Object o)` Writes the specified Java object to the buffer.
`ByteBuffer` | `putPrefixedString(CharSequence in, CharsetEncoder encoder)` Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`ByteBuffer` | `putPrefixedString(CharSequence in, int prefixLength, CharsetEncoder encoder)` Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`ByteBuffer` | `putPrefixedString(CharSequence val, int prefixLength, int padding, byte padValue, CharsetEncoder encoder)` Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`ByteBuffer` | `putPrefixedString(CharSequence in, int prefixLength, int padding, CharsetEncoder encoder)` Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.
`abstract ByteBuffer` | `putShort(int index, short value)`
`abstract ByteBuffer` | `putShort(short value)`
`ByteBuffer` | `putString(CharSequence val, CharsetEncoder encoder)` Writes the content of `in` into this buffer using the specified `encoder`.
`ByteBuffer` | `putString(CharSequence val, int fieldSize, CharsetEncoder encoder)` Writes the content of `in` into this buffer as a `NUL`-terminated string using the specified `encoder`.
`abstract void` | `release()` Releases the specified buffer to buffer pool.
`int` | `remaining()`
`abstract ByteBuffer` | `reset()`
`abstract ByteBuffer` | `rewind()`
`static void` | `setAllocator(ByteBufferAllocator newAllocator)` Changes the current allocator with the specified one to manage the allocated buffers from now.
`abstract ByteBuffer` | `setAutoExpand(boolean autoExpand)` Turns on or off `autoExpand`.
`abstract void` | `setPooled(boolean pooled)` Sets whether this buffer is returned back to the buffer pool when released.
`static void` | `setUseDirectBuffers(boolean useDirectBuffers)`
`ByteBuffer` | `skip(int size)` Forwards the position of this buffer as the specified `size` bytes.
`abstract ByteBuffer` | `slice()`
`ByteBuffer` | `sweep()` Clears this buffer and fills its content with `NUL`.
`ByteBuffer` | `sweep(byte value)` Clears this buffer and fills its content with `value`.
`String` | `toString()`
`static ByteBuffer` | `wrap(byte[] byteArray)` Wraps the specified byte array into MINA heap buffer.
`static ByteBuffer` | `wrap(byte[] byteArray, int offset, int length)` Wraps the specified byte array into MINA heap buffer.
`static ByteBuffer` | `wrap(ByteBuffer nioBuffer)` Wraps the specified NIO `ByteBuffer` into MINA buffer.

Methods inherited from class java.lang.Object
`clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

Constructor Detail

### ByteBuffer

    protected ByteBuffer()

Method Detail

### getAllocator

    public static ByteBufferAllocator getAllocator()

  Returns the current allocator which manages the allocated buffers.

### setAllocator

    public static void setAllocator(ByteBufferAllocator newAllocator)

  Changes the current allocator with the specified one to manage the allocated buffers from now.

### isUseDirectBuffers

    public static boolean isUseDirectBuffers()

### setUseDirectBuffers

    public static void setUseDirectBuffers(boolean useDirectBuffers)

### allocate

    public static ByteBuffer allocate(int capacity)

  Returns the direct or heap buffer which is capable of the specified size. This method tries to allocate direct buffer first, and then tries heap buffer if direct buffer memory is exhausted. Please use `allocate(int, boolean)` to allocate buffers of specific type.

  Parameters:
    `capacity` - the capacity of the buffer

### allocate

    public static ByteBuffer allocate(int capacity,
                                      boolean direct)

  Returns the buffer which is capable of the specified size.

  Parameters:
    `capacity` - the capacity of the buffer
    `direct` - `true` to get a direct buffer, `false` to get a heap buffer.

### wrap

    public static ByteBuffer wrap(ByteBuffer nioBuffer)

  Wraps the specified NIO `ByteBuffer` into MINA buffer.

### wrap

    public static ByteBuffer wrap(byte[] byteArray)

  Wraps the specified byte array into MINA heap buffer.

### wrap

    public static ByteBuffer wrap(byte[] byteArray,
                                  int offset,
                                  int length)

  Wraps the specified byte array into MINA heap buffer. Please note that MINA buffers are going to be pooled, and therefore there can be waste of memory if you wrap your byte array specifying `offset` and `length`.

### acquire

    public abstract void acquire()

  Increases the internal reference count of this buffer to defer automatic release. You have to invoke `release()` as many as you invoked this method to release this buffer.

  Throws:
    `IllegalStateException` - if you attempt to acquire already released buffer.

### release

    public abstract void release()

  Releases the specified buffer to buffer pool.

  Throws:
    `IllegalStateException` - if you attempt to release already released buffer.

### buf

    public abstract ByteBuffer buf()

  Returns the underlying NIO buffer instance.

### isDirect

    public abstract boolean isDirect()

  See Also:
    `ByteBuffer.isDirect()`

### isReadOnly

    public abstract boolean isReadOnly()

  See Also:
    `Buffer.isReadOnly()`

### capacity

    public abstract int capacity()

  See Also:
    `Buffer.capacity()`

### capacity

    public abstract ByteBuffer capacity(int newCapacity)

  Changes the capacity of this buffer.

### isAutoExpand

    public abstract boolean isAutoExpand()

  Returns `true` if and only if `autoExpand` is turned on.

### setAutoExpand

    public abstract ByteBuffer setAutoExpand(boolean autoExpand)

  Turns on or off `autoExpand`.

### expand

    public ByteBuffer expand(int expectedRemaining)

  Changes the capacity and limit of this buffer so this buffer get the specified `expectedRemaining` room from the current position. This method works even if you didn't set `autoExpand` to `true`.

### expand

    public abstract ByteBuffer expand(int pos,
                                      int expectedRemaining)

  Changes the capacity and limit of this buffer so this buffer get the specified `expectedRemaining` room from the specified `pos`. This method works even if you didn't set `autoExpand` to `true`.

### isPooled

    public abstract boolean isPooled()

  Returns `true` if and only if this buffer is returned back to the buffer pool when released.

  The default value of this property is `true` if and only if you allocated this buffer using `allocate(int)` or `allocate(int, boolean)`, or `false` otherwise. (i.e. `wrap(byte[])`, `wrap(byte[], int, int)`, and `wrap(java.nio.ByteBuffer)`)

### setPooled

    public abstract void setPooled(boolean pooled)

  Sets whether this buffer is returned back to the buffer pool when released.

  The default value of this property is `true` if and only if you allocated this buffer using `allocate(int)` or `allocate(int, boolean)`, or `false` otherwise. (i.e. `wrap(byte[])`, `wrap(byte[], int, int)`, and `wrap(java.nio.ByteBuffer)`)

### position

    public abstract int position()

  See Also:
    `Buffer.position()`

### position

    public abstract ByteBuffer position(int newPosition)

  See Also:
    `Buffer.position(int)`

### limit

    public abstract int limit()

  See Also:
    `Buffer.limit()`

### limit

    public abstract ByteBuffer limit(int newLimit)

  See Also:
    `Buffer.limit(int)`

### mark

    public abstract ByteBuffer mark()

  See Also:
    `Buffer.mark()`

### markValue

    public abstract int markValue()

  Returns the position of the current mark. This method returns `-1` if no mark is set.

### reset

    public abstract ByteBuffer reset()

  See Also:
    `Buffer.reset()`

### clear

    public abstract ByteBuffer clear()

  See Also:
    `Buffer.clear()`

### sweep

    public ByteBuffer sweep()

  Clears this buffer and fills its content with `NUL`. The position is set to zero, the limit is set to the capacity, and the mark is discarded.

### sweep

    public ByteBuffer sweep(byte value)

  Clears this buffer and fills its content with `value`. The position is set to zero, the limit is set to the capacity, and the mark is discarded.

### flip

    public abstract ByteBuffer flip()

  See Also:
    `Buffer.flip()`

### rewind

    public abstract ByteBuffer rewind()

  See Also:
    `Buffer.rewind()`

### remaining

    public int remaining()

  See Also:
    `Buffer.remaining()`

### hasRemaining

    public boolean hasRemaining()

  See Also:
    `Buffer.hasRemaining()`

### duplicate

    public abstract ByteBuffer duplicate()

  See Also:
    `ByteBuffer.duplicate()`

### slice

    public abstract ByteBuffer slice()

  See Also:
    `ByteBuffer.slice()`

### asReadOnlyBuffer

    public abstract ByteBuffer asReadOnlyBuffer()

  See Also:
    `ByteBuffer.asReadOnlyBuffer()`

### array

    public abstract byte[] array()

  See Also:
    `ByteBuffer.array()`

### arrayOffset

    public abstract int arrayOffset()

  See Also:
    `ByteBuffer.arrayOffset()`

### get

    public abstract byte get()

  See Also:
    `ByteBuffer.get()`

### getUnsigned

    public short getUnsigned()

  Reads one unsigned byte as a short integer.

### put

    public abstract ByteBuffer put(byte b)

  See Also:
    `ByteBuffer.put(byte)`

### get

    public abstract byte get(int index)

  See Also:
    `ByteBuffer.get(int)`

### getUnsigned

    public short getUnsigned(int index)

  Reads one byte as an unsigned short integer.

### put

    public abstract ByteBuffer put(int index,
                                   byte b)

  See Also:
    `ByteBuffer.put(int, byte)`

### get

    public abstract ByteBuffer get(byte[] dst,
                                   int offset,
                                   int length)

  See Also:
    `ByteBuffer.get(byte[], int, int)`

### get

    public ByteBuffer get(byte[] dst)

  See Also:
    `ByteBuffer.get(byte[])`

### put

    public abstract ByteBuffer put(ByteBuffer src)

  Writes the content of the specified `src` into this buffer.

### put

    public ByteBuffer put(ByteBuffer src)

  Writes the content of the specified `src` into this buffer.

### put

    public abstract ByteBuffer put(byte[] src,
                                   int offset,
                                   int length)

  See Also:
    `ByteBuffer.put(byte[], int, int)`

### put

    public ByteBuffer put(byte[] src)

  See Also:
    `ByteBuffer.put(byte[])`

### compact

    public abstract ByteBuffer compact()

  See Also:
    `ByteBuffer.compact()`

### toString

    public String toString()

  Overrides:
    `toString` in class `Object`

### hashCode

    public int hashCode()

  Overrides:
    `hashCode` in class `Object`

### equals

    public boolean equals(Object o)

  Overrides:
    `equals` in class `Object`

### compareTo

    public int compareTo(ByteBuffer that)

  Specified by:
    `compareTo` in interface `Comparable<ByteBuffer>`

### order

    public abstract ByteOrder order()

  See Also:
    `ByteBuffer.order()`

### order

    public abstract ByteBuffer order(ByteOrder bo)

  See Also:
    `ByteBuffer.order(ByteOrder)`

### getChar

    public abstract char getChar()

  See Also:
    `ByteBuffer.getChar()`

### putChar

    public abstract ByteBuffer putChar(char value)

  See Also:
    `ByteBuffer.putChar(char)`

### getChar

    public abstract char getChar(int index)

  See Also:
    `ByteBuffer.getChar(int)`

### putChar

    public abstract ByteBuffer putChar(int index,
                                       char value)

  See Also:
    `ByteBuffer.putChar(int, char)`

### asCharBuffer

    public abstract CharBuffer asCharBuffer()

  See Also:
    `ByteBuffer.asCharBuffer()`

### getShort

    public abstract short getShort()

  See Also:
    `ByteBuffer.getShort()`

### getUnsignedShort

    public int getUnsignedShort()

  Reads two bytes unsigned integer.

### putShort

    public abstract ByteBuffer putShort(short value)

  See Also:
    `ByteBuffer.putShort(short)`

### getShort

    public abstract short getShort(int index)

  See Also:
    `ByteBuffer.getShort()`

### getUnsignedShort

    public int getUnsignedShort(int index)

  Reads two bytes unsigned integer.

### putShort

    public abstract ByteBuffer putShort(int index,
                                        short value)

  See Also:
    `ByteBuffer.putShort(int, short)`

### asShortBuffer

    public abstract ShortBuffer asShortBuffer()

  See Also:
    `ByteBuffer.asShortBuffer()`

### getInt

    public abstract int getInt()

  See Also:
    `ByteBuffer.getInt()`

### getUnsignedInt

    public long getUnsignedInt()

  Reads four bytes unsigned integer.

### putInt

    public abstract ByteBuffer putInt(int value)

  See Also:
    `ByteBuffer.putInt(int)`

### getInt

    public abstract int getInt(int index)

  See Also:
    `ByteBuffer.getInt(int)`

### getUnsignedInt

    public long getUnsignedInt(int index)

  Reads four bytes unsigned integer.

### putInt

    public abstract ByteBuffer putInt(int index,
                                      int value)

  See Also:
    `ByteBuffer.putInt(int, int)`

### asIntBuffer

    public abstract IntBuffer asIntBuffer()

  See Also:
    `ByteBuffer.asIntBuffer()`

### getLong

    public abstract long getLong()

  See Also:
    `ByteBuffer.getLong()`

### putLong

    public abstract ByteBuffer putLong(long value)

  See Also:
    `ByteBuffer.putLong(int, long)`

### getLong

    public abstract long getLong(int index)

  See Also:
    `ByteBuffer.getLong(int)`

### putLong

    public abstract ByteBuffer putLong(int index,
                                       long value)

  See Also:
    `ByteBuffer.putLong(int, long)`

### asLongBuffer

    public abstract LongBuffer asLongBuffer()

  See Also:
    `ByteBuffer.asLongBuffer()`

### getFloat

    public abstract float getFloat()

  See Also:
    `ByteBuffer.getFloat()`

### putFloat

    public abstract ByteBuffer putFloat(float value)

  See Also:
    `ByteBuffer.putFloat(float)`

### getFloat

    public abstract float getFloat(int index)

  See Also:
    `ByteBuffer.getFloat(int)`

### putFloat

    public abstract ByteBuffer putFloat(int index,
                                        float value)

  See Also:
    `ByteBuffer.putFloat(int, float)`

### asFloatBuffer

    public abstract FloatBuffer asFloatBuffer()

  See Also:
    `ByteBuffer.asFloatBuffer()`

### getDouble

    public abstract double getDouble()

  See Also:
    `ByteBuffer.getDouble()`

### putDouble

    public abstract ByteBuffer putDouble(double value)

  See Also:
    `ByteBuffer.putDouble(double)`

### getDouble

    public abstract double getDouble(int index)

  See Also:
    `ByteBuffer.getDouble(int)`

### putDouble

    public abstract ByteBuffer putDouble(int index,
                                         double value)

  See Also:
    `ByteBuffer.putDouble(int, double)`

### asDoubleBuffer

    public abstract DoubleBuffer asDoubleBuffer()

  See Also:
    `ByteBuffer.asDoubleBuffer()`

### asInputStream

    public InputStream asInputStream()

  Returns an `InputStream` that reads the data from this buffer. `InputStream.read()` returns `-1` if the buffer position reaches to the limit.

### asOutputStream

    public OutputStream asOutputStream()

  Returns an `OutputStream` that appends the data into this buffer. Please note that the `OutputStream.write(int)` will throw a `BufferOverflowException` instead of an `IOException` in case of buffer overflow. Please set `autoExpand` property by calling `setAutoExpand(boolean)` to prevent the unexpected runtime exception.

### getHexDump

    public String getHexDump()

  Returns hexdump of this buffer.

### getString

    public String getString(CharsetDecoder decoder)
                     throws CharacterCodingException

  Reads a `NUL`-terminated string from this buffer using the specified `decoder` and returns it. This method reads until the limit of this buffer if no `NUL` is found.

  Throws:
    `CharacterCodingException`

### getString

    public String getString(int fieldSize,
                            CharsetDecoder decoder)
                     throws CharacterCodingException

  Reads a `NUL`-terminated string from this buffer using the specified `decoder` and returns it.

  Parameters:
    `fieldSize` - the maximum number of bytes to read
  Throws:
    `CharacterCodingException`

### putString

    public ByteBuffer putString(CharSequence val,
                                CharsetEncoder encoder)
                         throws CharacterCodingException

  Writes the content of `in` into this buffer using the specified `encoder`. This method doesn't terminate string with `NUL`. You have to do it by yourself.

  Throws:
    `BufferOverflowException` - if the specified string doesn't fit
    `CharacterCodingException`

### putString

    public ByteBuffer putString(CharSequence val,
                                int fieldSize,
                                CharsetEncoder encoder)
                         throws CharacterCodingException

  Writes the content of `in` into this buffer as a `NUL`-terminated string using the specified `encoder`.

  If the charset name of the encoder is UTF-16, you cannot specify odd `fieldSize`, and this method will append two `NUL`s as a terminator.

  Please note that this method doesn't terminate with `NUL` if the input string is longer than `fieldSize`.

  Parameters:
    `fieldSize` - the maximum number of bytes to write
  Throws:
    `CharacterCodingException`

### getPrefixedString

    public String getPrefixedString(CharsetDecoder decoder)
                             throws CharacterCodingException

  Reads a string which has a 16-bit length field before the actual encoded string, using the specified `decoder` and returns it. This method is a shortcut for `getPrefixedString(2, decoder)`.

  Throws:
    `CharacterCodingException`

### getPrefixedString

    public String getPrefixedString(int prefixLength,
                                    CharsetDecoder decoder)
                             throws CharacterCodingException

  Reads a string which has a length field before the actual encoded string, using the specified `decoder` and returns it.

  Parameters:
    `prefixLength` - the length of the length field (1, 2, or 4)
  Throws:
    `CharacterCodingException`

### putPrefixedString

    public ByteBuffer putPrefixedString(CharSequence in,
                                        CharsetEncoder encoder)
                                 throws CharacterCodingException

  Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`. This method is a shortcut for `putPrefixedString(in, 2, 0, encoder)`.

  Throws:
    `BufferOverflowException` - if the specified string doesn't fit
    `CharacterCodingException`

### putPrefixedString

    public ByteBuffer putPrefixedString(CharSequence in,
                                        int prefixLength,
                                        CharsetEncoder encoder)
                                 throws CharacterCodingException

  Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`. This method is a shortcut for `putPrefixedString(in, prefixLength, 0, encoder)`.

  Parameters:
    `prefixLength` - the length of the length field (1, 2, or 4)
  Throws:
    `BufferOverflowException` - if the specified string doesn't fit
    `CharacterCodingException`

### putPrefixedString

    public ByteBuffer putPrefixedString(CharSequence in,
                                        int prefixLength,
                                        int padding,
                                        CharsetEncoder encoder)
                                 throws CharacterCodingException

  Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`. This method is a shortcut for `putPrefixedString(in, prefixLength, padding, ( byte ) 0, encoder)`.

  Parameters:
    `prefixLength` - the length of the length field (1, 2, or 4)
    `padding` - the number of padded `NUL`s (1 (or 0), 2, or 4)
  Throws:
    `BufferOverflowException` - if the specified string doesn't fit
    `CharacterCodingException`

### putPrefixedString

    public ByteBuffer putPrefixedString(CharSequence val,
                                        int prefixLength,
                                        int padding,
                                        byte padValue,
                                        CharsetEncoder encoder)
                                 throws CharacterCodingException

  Writes the content of `in` into this buffer as a string which has a 16-bit length field before the actual encoded string, using the specified `encoder`.

  Parameters:
    `prefixLength` - the length of the length field (1, 2, or 4)
    `padding` - the number of padded bytes (1 (or 0), 2, or 4)
    `padValue` - the value of padded bytes
  Throws:
    `BufferOverflowException` - if the specified string doesn't fit
    `CharacterCodingException`

### getObject

    public Object getObject()
                     throws ClassNotFoundException

  Reads a Java object from the buffer using the context `ClassLoader` of the current thread.

  Throws:
    `ClassNotFoundException`

### getObject

    public Object getObject(ClassLoader classLoader)
                     throws ClassNotFoundException

  Reads a Java object from the buffer using the specified `classLoader`.

  Throws:
    `ClassNotFoundException`

### putObject

    public ByteBuffer putObject(Object o)

  Writes the specified Java object to the buffer.

### prefixedDataAvailable

    public boolean prefixedDataAvailable(int prefixLength)

  Returns `true` if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field. This method is identical with `prefixedDataAvailable( prefixLength, Integer.MAX_VALUE )`. Please not that using this method can allow DoS (Denial of Service) attack in case the remote peer sends too big data length value. It is recommended to use `prefixedDataAvailable(int, int)` instead.

  Parameters:
    `prefixLength` - the length of the prefix field (1, 2, or 4)
  Throws:
    `IllegalArgumentException` - if prefixLength is wrong
    `BufferDataException` - if data length is negative

### prefixedDataAvailable

    public boolean prefixedDataAvailable(int prefixLength,
                                         int maxDataLength)

  Returns `true` if this buffer contains a data which has a data length as a prefix and the buffer has remaining data as enough as specified in the data length field.

  Parameters:
    `prefixLength` - the length of the prefix field (1, 2, or 4)
    `maxDataLength` - the allowed maximum of the read data length
  Throws:
    `IllegalArgumentException` - if prefixLength is wrong
    `BufferDataException` - if data length is negative or greater then `maxDataLength`

### skip

    public ByteBuffer skip(int size)

  Forwards the position of this buffer as the specified `size` bytes.

### fill

    public ByteBuffer fill(byte value,
                           int size)

  Fills this buffer with the specified value. This method moves buffer position forward.

### fillAndReset

    public ByteBuffer fillAndReset(byte value,
                                   int size)

  Fills this buffer with the specified value. This method does not change buffer position.

### fill

    public ByteBuffer fill(int size)

  Fills this buffer with `NUL (0x00)`. This method moves buffer position forward.

### fillAndReset

    public ByteBuffer fillAndReset(int size)

  Fills this buffer with `NUL (0x00)`. This method does not change buffer position.

### autoExpand

    protected ByteBuffer autoExpand(int expectedRemaining)

  This method forwards the call to `expand(int)` only when `autoExpand` property is `true`.

### autoExpand

    protected ByteBuffer autoExpand(int pos,
                                    int expectedRemaining)

  This method forwards the call to `expand(int)` only when `autoExpand` property is `true`.

Overview | Package | Class | Use | Tree | Deprecated | Index | Help
PREV CLASS NEXT CLASS | FRAMES NO FRAMES
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD

Copyright © 2004-2008 Apache MINA Project. All Rights Reserved.