IOBuffer (Rumi 4.0.595 API)

java.lang.Object
- com.neeve.io.IOBuffer

All Implemented Interfaces:

UtlPool.Item<IOBuffer>
```
public class IOBuffer
extends Object
implements UtlPool.Item<IOBuffer>
```
Implements an IO buffer.
An IOBuffer is a poolable, native ByteBuffer. It serves as the unit for IO (network or otherwise).

An IOBuffer maintains the following markers:
- Capacity
- Length
When an IO buffer is created, it allocates a ByteBuffer from an appropriate pool. The capacity of the underlying byte buffer is the requested of the IO buffer rounded up to the nearest fixed length memory slab. The capacity of an IO buffer is always equal to the capacity of its underlying ByteBuffer. The length of an IO buffer is initially set to requested length of a newly created IO buffer and only changed by ensureCapacity(com.neeve.io.IOBuffer, int, boolean) if the space between length and capacity can be used to satisfy the increase in requested capacity.

While the underlying ByteBuffer has not been taken by the user, the markers of the byte buffer honor the following contract:
- position is always equal to 0
- limit is always eqaual to the IO buffer length
- capacity is always eaual to the initial length of the IO buffer rounded up to the nearest multiple of 2.

There are circumstances when one needs direct access to the ByteBuffer that underlies the IOBuffer. The usage pattern, in such a situation, is to take the byte buffer from the IO buffer, use the buffer and then release the buffer back to the IO buffer. Take is accomplished via takeBuffer() and release is accomplished via releaseBuffer(). While the byte buffer is taken by the caller, a IOBuffer considers its underlying ByteBuffer to be owned by the caller and any method implemented by IOBuffer that returns the underlying ByteBuffer (e.g. getBufferUnsafe()) or updates the markers of the underlying ByteBuffer byte buffer (e.g. ensureCapacity(IOBuffer, int, boolean)) will throw an exception. The caller who has taken a byte buffer from an IO buffer is free to update the markers of the buffer while the buffer is taken. Once released, the byte buffers markers will be restored to honor the above describe marker contract.

Threading:

An IO buffer is not safe for concurrent access by multiple threads except when the contents of the underlying ByteBuffer is being read concurrently by multiple threads using methods using methods that utilize the getTo methods which don't mutate the underlying buffer pointers.

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`IOBuffer.ParsedCount` Used to store the number of bytes parsed during a deserialization process
`static class`	`IOBuffer.VarintDeserializeLength` Used to store the number of bytes deserialized by a varint get

Method Summary

All Methods Static Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`IOBuffer`	`acquire()` Acquire a reference to an IO buffer This method increments an IO buffer's ownership count.
`static ByteBuffer`	`allocateByteBuffer(int capacity, boolean direct)` Allocate a byte buffer
`static long`	`allocateMemoryBlock(long length)` Allocate a block of memory
`static long`	`allocateMemoryBlock(long length, boolean zeroout)` Allocate a block of memory
`static int`	`calcLongAsASCIICharSequenceLength(long val)` Get serialized length of a long value as an ASCII sequence
`static int`	`calculateUTF8Length(char c)` Calculate the length of the character encoded as UTF-8.
`static int`	`calculateUTF8Length(CharSequence str)` Calculate the length of the character sequence encoded as UTF-8.
`IOBuffer`	`copy()` Creates a copy of this IOBuffer.
`static void`	`copy(long src, int srcoff, long dest, int destoff, int len)` Copy the contents of one memory region to another
`static IOBuffer`	`create(int length)` Create a new IO buffer
`static IOBuffer`	`createNative(int length)` Deprecated.
`void`	`dispose()` Dispose off an IO buffer This method is equivalent to `dispose(this.highwater)`
`void`	`dispose(int highwater)` Dispose of an IO buffer.
`static String`	`dump(long addr, int offset, int len)` Dump the contents of a memory region.
`static IOBuffer`	`ensureCapacity(IOBuffer buffer, int val, boolean initFromExisting)` Ensure an IO buffer has enough capacity
`static long`	`ensureMemoryBlockCapacity(long addr, long length, int newlength)` Ensure a memory block has enough capacity
`static long`	`ensureMemoryBlockCapacity(long addr, long length, int newlength, boolean zeroout)` Ensure a memory block has enough capacity
`static void`	`freeMemoryBlock(long addr, int length)` Free a native block of memory
`char`	`getASCIIChar(int offset)` Deserialize a char value from an IO buffer serialized using ASCII encoding
`static char`	`getASCIIChar(long addr, int offset)` Deserialize a char value seerialized as an ASCII char from a specific memory location
`String`	`getASCIICharSequence(int offset, int len)` Deserialize a character sequence from an IO buffer serialized using ASCII encoding
`static String`	`getASCIICharSequence(long addr, int offset, int len)` Deserialize a character sequence encoded as ASCII at a specific memory location as a string value
`ByteBuffer`	`getBuffer()` Deprecated. This method has been deprecated in favor of `takeBuffer()` and `releaseBuffer()`
`ByteBuffer`	`getBufferUnsafe()` Get the raw underlying byte buffer underlying an IO buffer.
`byte`	`getByte(int offset)` Deserialize a byte value from an IO buffer
`static byte`	`getByte(long addr, int offset)` Deserialize a byte value from a specific memory location
`static ByteOrder`	`getByteOrder()` Get the byte order of the created IO buffers By default, data written by IO buffers are encoded using the little endian format.
`int`	`getCapacity()` Get the buffer capacity
`char`	`getChar(int offset)` Deserialize a char value from an IO buffer
`static char`	`getChar(long addr, int offset)` Deserialize a char value from a specific memory location
`double`	`getDouble(int offset)` Deserialize a double value from an IO buffer
`static double`	`getDouble(long addr, int offset)` Deserialize a double value from a specific memory location
`double`	`getDoubleFromASCIICharSequence(int offset)` Deserialize a double value from an IO buffer serialized as an ASCII sequence
`static double`	`getDoubleFromASCIICharSequence(long addr, int offset, char terminationMarker, int limit, IOBuffer.ParsedCount parsedCount)` Deserialize a double value serialized as an ASCII sequence at a specific memory location
`float`	`getFloat(int offset)` Deserialize a float value from an IO buffer
`static float`	`getFloat(long addr, int offset)` Deserialize a float value from a specific memory location
`int`	`getInt(int offset)` Deserialize an int value from an IO buffer
`static int`	`getInt(long addr, int offset)` Deserialize an integer value from a specific memory location
`IOBuffer`	`getIOBuffer()` Deprecated.
`int`	`getLength()` Get the buffer length
`long`	`getLong(int offset)` Deserialize a long value from an IO buffer
`static long`	`getLong(long addr, int offset)` Deserialize an long value from a specific memory location
`long`	`getLongFromASCIICharSequence(int offset, char terminationMarker, int limit, IOBuffer.ParsedCount parsedCount)` Get a long value serialized as an ASCII sequence
`static long`	`getLongFromASCIICharSequence(long addr, int offset, char terminationMarker, int limit, IOBuffer.ParsedCount parsedCount)` Deserialize a long value serialized as an ASCII sequence at a specific memory location
`long`	`getNativeAddress()` Get the native address of the buffer's underlying storage
`int`	`getOwnerCount()` Get an IO buffer's ownership count.
`UtlPool<IOBuffer>`	`getPool()` Implementation of UtlPool.Item#getPool.
`short`	`getShort(int offset)` Deserialize a short value from an IO buffer
`static short`	`getShort(long addr, int offset)` Deserialize a short value from a specific memory location
`void`	`getTo(int offset, byte[] array, int arrayoffset, int numelem)` Deserialize a section of a byte array from an IO buffer
`void`	`getTo(int offset, ByteBuffer dest, int len)` Copy the data from an IO buffer to a ByteBuffer
`void`	`getTo(int offset, ByteBuffer dest, int bufferOffset, int len)` Copy the data from an IO buffer to a ByteBuffer
`void`	`getTo(int offset, char[] array, int arrayoffset, int numelem)` Deserialize a section of a char array from an IO buffer
`void`	`getTo(int offset, double[] array, int arrayoffset, int numelem)` Deserialize a section of a double array from an IO buffer
`void`	`getTo(int offset, float[] array, int arrayoffset, int numelem)` Deserialize a section of a float array from an IO buffer
`void`	`getTo(int offset, int[] array, int arrayoffset, int numelem)` Deserialize a section of a int array from an IO buffer
`void`	`getTo(int offset, IOBuffer dest, int destoff, int len)` Copy the contents of a section of an IO buffer to another IO buffer
`void`	`getTo(int offset, long[] array, int arrayoffset, int numelem)` Deserialize a section of a long array from an IO buffer
`void`	`getTo(int offset, long addr, int addroffset, int len)` Copy a section of an IO buffer to a memory region
`void`	`getTo(int offset, short[] array, int arrayoffset, int numelem)` Deserialize a section of a short array from an IO buffer
`static void`	`getTo(long addr, int offset, byte[] array, int arrayoffset, int numelem)` Deserialize a section of a byte array from a specific memory location
`static void`	`getTo(long addr, int offset, ByteBuffer buffer, int len)` Deserialize a section of a ByteBuffer from a specific memory location
`static void`	`getTo(long addr, int offset, ByteBuffer buffer, int bufferOffset, int len)` Deserialize a section of a ByteBuffer from a specific memory location
`static void`	`getTo(long addr, int offset, char[] array, int arrayoffset, int numelem)` Deserialize a section of a char array from a specific memory location
`static void`	`getTo(long addr, int offset, double[] array, int arrayoffset, int numelem)` Deserialize a section of a double array from a specific memory location
`static void`	`getTo(long addr, int offset, float[] array, int arrayoffset, int numelem)` Deserialize a section of a float array from a specific memory location
`static void`	`getTo(long addr, int offset, int[] array, int arrayoffset, int numelem)` Deserialize a section of an int array from a specific memory location
`static void`	`getTo(long addr, int offset, long[] array, int arrayoffset, int numelem)` Deserialize a section of a long array from a specific memory location
`static void`	`getTo(long addr, int offset, short[] array, int arrayoffset, int numelem)` Deserialize a section of a short array from a specific memory location
`int`	`getUnsignedByte(int offset)` Deserialize an unsigned byte value from an IO buffer
`static int`	`getUnsignedByte(long addr, int offset)` Deserialize an unsigned byte value from a specific memory location
`long`	`getUnsignedInt(int offset)` Deserialize an unsigned int value from an IO buffer
`static long`	`getUnsignedInt(long addr, int offset)` Deserialize an unsigned integer value from a specific memory location
`int`	`getUnsignedShort(int offset)` Deserialize an unsigned short value from an IO buffer
`static int`	`getUnsignedShort(long addr, int offset)` Deserialize an unsigned short value from a specific memory location
`String`	`getUTF8CharSequence(int offset, int len)` Deserialize a character sequence from an IO buffer serialized using UTF-8 encoding
`static String`	`getUTF8CharSequence(long addr, int offset, int len)` Deserialize a character sequence encoded as UTF-8 at a specific memory location as a string value
`int`	`getVarint32(int offset, IOBuffer.VarintDeserializeLength deserializeLength)` Deserialize an int value from an IO buffer serialized as a 32-bit varint
`static int`	`getVarint32(long addr, int offset, IOBuffer.VarintDeserializeLength deserializeLength)` Deserialize an integer value serialized as a 32-bit varint from a specific memory location
`long`	`getVarint64(int offset, IOBuffer.VarintDeserializeLength deserializeLength)` Deserialize a long value from an IO buffer serialized as a 64-bit varint
`static long`	`getVarint64(long addr, int offset, IOBuffer.VarintDeserializeLength deserializeLength)` Deserialize a long value serialized as a 64-bit varint from a specific memory location
`IOBuffer`	`init()` Implementation of UtlPool.Item#init.
`static int`	`numSlabs()` Get the number of slabs
`int`	`putASCIIChar(int offset, char val)` Serialize a char value to an IO buffer using ASCII encoding
`static int`	`putASCIIChar(long addr, int offset, char val)` Serialize a char value to a specific memory location encoded as ASCII
`int`	`putASCIICharSequence(int offset, CharSequence val)` Serialize a character sequence to an IO buffer using ASCII encoding
`int`	`putASCIICharSequence(int offset, CharSequence val, int start, int end)` Serialize a character sequence to an IO buffer using ASCII encoding
`static int`	`putASCIICharSequence(long addr, int offset, CharSequence val)` Serialize a character sequence to a specific memory location encoded as ASCII
`static int`	`putASCIICharSequence(long addr, int offset, CharSequence val, int start, int end)` Serialize an character sequence to a specific memory location encoded as ASCII
`void`	`putByte(int offset, byte val)` Serialize a byte value to an IO buffer
`static void`	`putByte(long addr, int offset, byte val)` Serialize a byte value to a specific memory location
`void`	`putChar(int offset, char val)` Serialize a char value to an IO buffer
`static void`	`putChar(long addr, int offset, char val)` Serialize a char value to a specific memory location
`void`	`putDouble(int offset, double val)` Serialize a double value to an IO buffer
`static void`	`putDouble(long addr, int offset, double val)` Serialize a double value to a specific memory location
`int`	`putDoubleAsASCIICharSequence(int offset, double val, int precision)` Serialize a double value to an IO buffer as an ASCII character sequence
`static int`	`putDoubleAsASCIICharSequence(long addr, int offset, double val, int precision)` Serialize a double value as an ASCII sequence to a specific memory location This method invokes `putDoubleAsASCIICharSequence(addr, offset, val, precision, false)`
`static int`	`putDoubleAsASCIICharSequence(long addr, int offset, double val, int precision, boolean mock)` Serialize a double value as an ASCII sequence to a specific memory location
`void`	`putFloat(int offset, float val)` Serialize a float value to an IO buffer
`static void`	`putFloat(long addr, int offset, float val)` Serialize a float value to a specific memory location
`void`	`putFrom(int offset, byte[] array, int arrayoffset, int numelem)` Serialize a section of a byte array to an IO buffer
`void`	`putFrom(int offset, ByteBuffer src)` Copy the data from a ByteBuffer to an IO buffer
`void`	`putFrom(int offset, ByteBuffer src, int bufferOffset, int len)` Copy the data from a ByteBuffer to an IO buffer
`void`	`putFrom(int offset, char[] array, int arrayoffset, int numelem)` Serialize a section of a char array to an IO buffer
`void`	`putFrom(int offset, double[] array, int arrayoffset, int numelem)` Serialize a section of a double array to an IO buffer
`void`	`putFrom(int offset, float[] array, int arrayoffset, int numelem)` Serialize a section of a float array to an IO buffer
`void`	`putFrom(int offset, int[] array, int arrayoffset, int numelem)` Serialize a section of a int array to an IO buffer
`void`	`putFrom(int offset, IOBuffer src, int srcoff, int len)` Copy the contents of a section of an IO buffer to another IO buffer
`void`	`putFrom(int offset, long[] array, int arrayoffset, int numelem)` Serialize a section of a long array to an IO buffer
`void`	`putFrom(int offset, long addr, int addroffset, int len)` Copy a section of a memory region to an IO buffer
`void`	`putFrom(int offset, short[] array, int arrayoffset, int numelem)` Serialize a section of a short array to an IO buffer
`static void`	`putFrom(long addr, int offset, byte[] array, int arrayoffset, int numelem)` Serialize a section of a byte array to a specific memory location
`static void`	`putFrom(long addr, int offset, ByteBuffer buffer)` Serialize a section of a ByteBuffer to a specific memory location
`static void`	`putFrom(long addr, int offset, ByteBuffer buffer, int bufferOffset, int len)` Serialize a section of a ByteBuffer to a specific memory location
`static void`	`putFrom(long addr, int offset, char[] array, int arrayoffset, int numelem)` Serialize a section of a char array to a specific memory location
`static void`	`putFrom(long addr, int offset, double[] array, int arrayoffset, int numelem)` Serialize a section of a double array to a specific memory location
`static void`	`putFrom(long addr, int offset, float[] array, int arrayoffset, int numelem)` Serialize a section of a float array to a specific memory location
`static void`	`putFrom(long addr, int offset, int[] array, int arrayoffset, int numelem)` Serialize a section of an integer array to a specific memory location
`static void`	`putFrom(long addr, int offset, long[] array, int arrayoffset, int numelem)` Serialize a section of a long array to a specific memory location
`static void`	`putFrom(long addr, int offset, short[] array, int arrayoffset, int numelem)` Serialize a section of a short array to a specific memory location
`void`	`putInt(int offset, int val)` Serialize an int value to an IO buffer
`static void`	`putInt(long addr, int offset, int val)` Serialize an integer value to a specific memory location
`void`	`putLong(int offset, long val)` Serialize a long value to an IO buffer
`static void`	`putLong(long addr, int offset, long val)` Serialize an long value to a specific memory location
`int`	`putLongAsASCIICharSequence(int offset, long val)` Serialize a long value to an IO buffer as an ASCII character sequence
`static int`	`putLongAsASCIICharSequence(long addr, int offset, long val)` Serialize an long value as an ASCII sequence to a specific memory location This method invokes `putLongAsASCIICharSequence(addr, offset, val, false)`
`static int`	`putLongAsASCIICharSequence(long addr, int offset, long val, boolean mock)` Serialize an long value as an ASCII sequence to a specific memory location
`void`	`putShort(int offset, short val)` Serialize a short value to an IO buffer
`static void`	`putShort(long addr, int offset, short val)` Serialize a short value to a specific memory location
`int`	`putUTF8Char(int offset, char val)` Serialize a char value to an IO buffer using UTF8 encoding
`static int`	`putUTF8Char(long addr, int offset, char val)` Serialize a char value to a specific memory location encoded as UTF-8
`int`	`putUTF8CharSequence(int offset, CharSequence val)` Serialize a character sequence to an IO buffer using UTF-8 encoding
`int`	`putUTF8CharSequence(int offset, CharSequence val, int start, int end)` Serialize a character sequence to an IO buffer using UTF-8 encoding
`int`	`putUTF8CharSequence(int offset, CharSequence val, int utflen, int start, int end)` Serialize a character sequence to an IO buffer using UTF-8 encoding
`static int`	`putUTF8CharSequence(long addr, int offset, CharSequence val)` Serialize a character sequence to a specific memory location encoded as UTF-8
`static int`	`putUTF8CharSequence(long addr, int offset, CharSequence val, int start, int end)` Serialize a character sequence to a specific memory location encoded as UTF-8
`void`	`putVarint32(int offset, int val)` Serialize an int value to an IO buffer as a 32-bit varint
`static int`	`putVarint32(long addr, int offset, int val)` Serialize an integer value as a 32-bit varint to a specific memory location
`void`	`putVarint64(int offset, long val)` Serialize a long value to an IO buffer as a 64-bit varint
`static int`	`putVarint64(long addr, int offset, long val)` Serialize a long value as a 64-bit varint to a specific memory location
`IOBuffer`	`releaseBuffer()` Release an IO buffer's underlying buffer previously taken via `takeBuffer()`
`IOBuffer`	`setNoWipe()` Set to not wipe an IO buffer on dispose By default, an IO buffer is wiped clean when disposed.
`IOBuffer`	`setPool(UtlPool<IOBuffer> pool)` Implementation of UtlPool.Item#setPool.
`static int`	`slab(int val)` Get the slab number for a buffer length When an IO buffer is allocated, what is returned is actually a fixed length buffer from a particular fixed length buffer slab (the system maintains a certain number of slabs with each slab holding fixed length buffer of a particular size).
`static int`	`slabSize(int val)` Get the slab size for a buffer length This method returns the actual size (capacity) of the buffer that would be returned for an allocation request of a particular size i.e. this method returns the size of slab that a request buffer length would resolve to
`static int`	`smallestSlabSize()` Get the smallest slab size
`ByteBuffer`	`takeBuffer()` Take an IO buffer's underlying byte buffer This method temporarily transfers ownership of an IO buffer's underlying byte buffer to the caller.
`String`	`toString()` Return a string representation of a buffer
`static int`	`varint32SerializedLength(int val)` Return the serialized length of a 32-bit value serialized as a varint
`static int`	`varint64SerializedLength(long val)` Return the serialized length of a 64-bit value serialized as a varint
`static void`	`wipe(long addr, int addroff, int len)` Wipe a section of a memory region
`static IOBuffer`	`wrap(ByteBuffer buffer)` Create an IO buffer wrapped around a byte buffer
`static ByteBuffer`	`wrapByteBuffer(byte[] array)` Wrap a byte buffer
`static ByteBuffer`	`wrapByteBuffer(byte[] array, int offset, int length)` Wrap a byte buffer

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait

- Method Detail
  - create
```
public static IOBuffer create(int length)
```
    Create a new IO buffer
    
    Parameters:
    
    length - The length of the buffer to create.
    
    Returns:
    
    Returns the created IO buffer.
    
    Threading:
    
    This method is safe for concurrent access by multiple threads
  - createNative
```
@Deprecated
public static IOBuffer createNative(int length)
```
    Deprecated.
    
    Create a new IO buffer
    Invoking this method is the same as invoking create(length).
  - wrap
```
public static IOBuffer wrap(ByteBuffer buffer)
```
    Create an IO buffer wrapped around a byte buffer
    
    Parameters:
    
    buffer - The byte buffer to wrap around
    
    Returns:
    
    Returns the created IO buffer.
    
    Threading:
    
    This method is safe for concurrent access by multiple threads
  - allocateByteBuffer
```
public static final ByteBuffer allocateByteBuffer(int capacity,
                                                  boolean direct)
```
    Allocate a byte buffer
    
    Parameters:
    
    capacity - The buffer capacity
    
    direct - Whether the allocated byte buffer is direct or not
    This method allocates a new byte buffer with the same endianness of buffers that back IO buffers
  - wrapByteBuffer
```
public static final ByteBuffer wrapByteBuffer(byte[] array,
                                              int offset,
                                              int length)
```
    Wrap a byte buffer
    
    Parameters:
    
    array - The array to wrap the buffer around
    
    offset - The offset into the array from where to wrap
    
    length - The length to wrap
    This method allocates a new byte buffer wrapped around an array with the same endianness of buffers that back IO buffers
  - wrapByteBuffer
```
public static final ByteBuffer wrapByteBuffer(byte[] array)
```
    Wrap a byte buffer
    
    Parameters:
    
    array - The array to wrap the buffer around
    This method invokes wrapByteBuffer(array, 0, array.length)
  - getByteOrder
```
public static final ByteOrder getByteOrder()
```
    Get the byte order of the created IO buffers
    By default, data written by IO buffers are encoded using the little endian format. However, setting nv.compat.3x.io changes the default to big endian. The byte order to use can also be set using the nv.io.byteorder configuration parameter. However, this should be done VERY carefully and done across all participants exchanging messages or sharing stored data.
  - ensureCapacity
```
public static final IOBuffer ensureCapacity(IOBuffer buffer,
                                            int val,
                                            boolean initFromExisting)
```
    Ensure an IO buffer has enough capacity
    
    Parameters:
    
    buffer - The buffer to check. Can be null in which case this method creates and returns a new IO buffer
    
    val - Minimum length the buffer needs to have.
    
    initFromExisting - Indicates whether a new buffer, if created, should be initialized from the existing buffer or not.
    This method checks to see if a supplied IO buffer has enough capacity. The supplied buffer can be null in which case a new buffer of length equal to supplied length is created and returned. If a non-null buffer is supplied, the this method checks if the buffer capacity is large enough to accommodate the supplied length. If so, it adjusts the buffer length to supplied length and returns the supplied buffer. Otherwise, it creates a new buffer, initializes the buffer from the existing buffer, disposes the old buffer and returns the new buffer
  - slab
```
public static final int slab(int val)
```
    Get the slab number for a buffer length
    When an IO buffer is allocated, what is returned is actually a fixed length buffer from a particular fixed length buffer slab (the system maintains a certain number of slabs with each slab holding fixed length buffer of a particular size). This method returns the number of the slab from where the buffer would be returned for a particular allocation length
    
    Parameters:
    
    val - The buffer length
  - slabSize
```
public static final int slabSize(int val)
```
    Get the slab size for a buffer length
    This method returns the actual size (capacity) of the buffer that would be returned for an allocation request of a particular size i.e. this method returns the size of slab that a request buffer length would resolve to
    
    Parameters:
    
    val - The buffer length
    
    Returns:
    
    the actual size of the buffer that would be allocated for the requested size
  - smallestSlabSize
```
public static final int smallestSlabSize()
```
    Get the smallest slab size
  - numSlabs
```
public static final int numSlabs()
```
    Get the number of slabs
  - allocateMemoryBlock
```
public static final long allocateMemoryBlock(long length,
                                             boolean zeroout)
```
    Allocate a block of memory
    
    Parameters:
    
    length - The length of the block of memory to allocate
    
    zeroout - Indicates whether the allocated block should be zeroed out
  - allocateMemoryBlock
```
public static final long allocateMemoryBlock(long length)
```
    Allocate a block of memory
    
    Parameters:
    
    length - The length of the block of memory to allocate
    This method invokes allocateMemoryBlock(length, true)
  - ensureMemoryBlockCapacity
```
public static final long ensureMemoryBlockCapacity(long addr,
                                                   long length,
                                                   int newlength,
                                                   boolean zeroout)
```
    Ensure a memory block has enough capacity
    
    Parameters:
    
    addr - The pointer to the current block of memory whose capacity needs to be ensured
    
    length - The length the current memory block
    
    newlength - The length the memory block needs to be
    
    zeroout - Indicates whether the newly allocated portion of the memory should be zeroed out
  - ensureMemoryBlockCapacity
```
public static final long ensureMemoryBlockCapacity(long addr,
                                                   long length,
                                                   int newlength)
```
    Ensure a memory block has enough capacity
    
    Parameters:
    
    addr - The pointer to the current block of memory whose capacity needs to be ensured
    
    length - The length the current memory block
    
    newlength - The length the memory block needs to be
    This method invokes ensureMemoryBlockCapacity(addr, length, newlength, true)
  - freeMemoryBlock
```
public static final void freeMemoryBlock(long addr,
                                         int length)
```
    Free a native block of memory
  - calculateUTF8Length
```
public static final int calculateUTF8Length(char c)
```
    Calculate the length of the character encoded as UTF-8.
    
    Parameters:
    
    c - The character whose UTF-8 length to calculate.
    
    Returns:
    
    The number of bytes needed to encode the character.
  - calculateUTF8Length
```
public static final int calculateUTF8Length(CharSequence str)
```
    Calculate the length of the character sequence encoded as UTF-8.
    
    Parameters:
    
    str - The str whose UTF-8 length to calculate.
    
    Returns:
    
    The number of bytes needed to encode the string.
  - putByte
```
public static final void putByte(long addr,
                                 int offset,
                                 byte val)
```
    Serialize a byte value to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The byte value to serialize
  - getByte
```
public static final byte getByte(long addr,
                                 int offset)
```
    Deserialize a byte value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The byte value.
  - getUnsignedByte
```
public static final int getUnsignedByte(long addr,
                                        int offset)
```
    Deserialize an unsigned byte value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The byte value.
  - putShort
```
public static final void putShort(long addr,
                                  int offset,
                                  short val)
```
    Serialize a short value to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The short value to serialize
  - getShort
```
public static final short getShort(long addr,
                                   int offset)
```
    Deserialize a short value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The short value.
  - getUnsignedShort
```
public static final int getUnsignedShort(long addr,
                                         int offset)
```
    Deserialize an unsigned short value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The short value.
  - putChar
```
public static final void putChar(long addr,
                                 int offset,
                                 char val)
```
    Serialize a char value to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The char value to serialize
  - putASCIIChar
```
public static final int putASCIIChar(long addr,
                                     int offset,
                                     char val)
```
    Serialize a char value to a specific memory location encoded as ASCII
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The char value to serialize
    
    Returns:
    
    the number of bytes serialized
  - putUTF8Char
```
public static final int putUTF8Char(long addr,
                                    int offset,
                                    char val)
```
    Serialize a char value to a specific memory location encoded as UTF-8
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The char value to serialize
    
    Returns:
    
    the number of bytes serialized
    
    Throws:
    
    IllegalArgumentException - if the supplied character is part of a surrogate pair
  - getChar
```
public static final char getChar(long addr,
                                 int offset)
```
    Deserialize a char value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The char value.
  - getASCIIChar
```
public static final char getASCIIChar(long addr,
                                      int offset)
```
    Deserialize a char value seerialized as an ASCII char from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The char value.
  - putInt
```
public static final void putInt(long addr,
                                int offset,
                                int val)
```
    Serialize an integer value to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The integer value to serialize
  - getInt
```
public static final int getInt(long addr,
                               int offset)
```
    Deserialize an integer value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The int value.
  - getUnsignedInt
```
public static final long getUnsignedInt(long addr,
                                        int offset)
```
    Deserialize an unsigned integer value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The int value.
  - putFloat
```
public static final void putFloat(long addr,
                                  int offset,
                                  float val)
```
    Serialize a float value to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The float value to serialize
  - getFloat
```
public static final float getFloat(long addr,
                                   int offset)
```
    Deserialize a float value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The float value.
  - putLong
```
public static final void putLong(long addr,
                                 int offset,
                                 long val)
```
    Serialize an long value to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The long value to serialize
  - calcLongAsASCIICharSequenceLength
```
public static final int calcLongAsASCIICharSequenceLength(long val)
```
    Get serialized length of a long value as an ASCII sequence
    
    Parameters:
    
    val - The long value to serialize
    
    Returns:
    
    Returns the serialized length
  - putLongAsASCIICharSequence
```
public static final int putLongAsASCIICharSequence(long addr,
                                                   int offset,
                                                   long val,
                                                   boolean mock)
```
    Serialize an long value as an ASCII sequence to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value. This parameter is ignored if mock is set to true
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value. This parameter is ignored if mock is set to true
    
    val - The long value to serialize
    
    mock - Perform a mock put i.e. do not actually add any data. This parameter should be set to true if the method is needed to determine the length of the serialized form of val
    
    Returns:
    
    Returns the serialized length
  - putLongAsASCIICharSequence
```
public static final int putLongAsASCIICharSequence(long addr,
                                                   int offset,
                                                   long val)
```
    Serialize an long value as an ASCII sequence to a specific memory location This method invokes putLongAsASCIICharSequence(addr, offset, val, false)
  - getLong
```
public static final long getLong(long addr,
                                 int offset)
```
    Deserialize an long value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The long value.
  - getLongFromASCIICharSequence
```
public static final long getLongFromASCIICharSequence(long addr,
                                                      int offset,
                                                      char terminationMarker,
                                                      int limit,
                                                      IOBuffer.ParsedCount parsedCount)
```
    Deserialize a long value serialized as an ASCII sequence at a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    terminationMarker - The marker character that terminates where the long value ends
    
    limit - The position at which the memory region becomes invalid
    
    Returns:
    
    The long value.
  - putDouble
```
public static final void putDouble(long addr,
                                   int offset,
                                   double val)
```
    Serialize a double value to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The double value to serialize
  - putDoubleAsASCIICharSequence
```
public static final int putDoubleAsASCIICharSequence(long addr,
                                                     int offset,
                                                     double val,
                                                     int precision,
                                                     boolean mock)
```
    Serialize a double value as an ASCII sequence to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value. This parameter is ignored if mock is set to true
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value. This parameter is ignored if mock is set to true
    
    val - The double value to serialize
    
    precision - The double value precision
    
    mock - Perform a mock put i.e. do not actually add any data. This parameter should be set to true if the method is needed to determine the length of the serialized form of val
    
    Returns:
    
    Returns the serialized length
  - putDoubleAsASCIICharSequence
```
public static final int putDoubleAsASCIICharSequence(long addr,
                                                     int offset,
                                                     double val,
                                                     int precision)
```
    Serialize a double value as an ASCII sequence to a specific memory location This method invokes putDoubleAsASCIICharSequence(addr, offset, val, precision, false)
  - getDouble
```
public static final double getDouble(long addr,
                                     int offset)
```
    Deserialize a double value from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    Returns:
    
    The double value.
  - getDoubleFromASCIICharSequence
```
public static final double getDoubleFromASCIICharSequence(long addr,
                                                          int offset,
                                                          char terminationMarker,
                                                          int limit,
                                                          IOBuffer.ParsedCount parsedCount)
```
    Deserialize a double value serialized as an ASCII sequence at a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    terminationMarker - The marker character that terminates where the long value ends
    
    limit - The position at which the memory region becomes invalid
    
    Returns:
    
    The double value.
  - putASCIICharSequence
```
public static final int putASCIICharSequence(long addr,
                                             int offset,
                                             CharSequence val,
                                             int start,
                                             int end)
```
    Serialize an character sequence to a specific memory location encoded as ASCII
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the sequence
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the sequence
    
    val - The character sequence to serialize
    
    start - The first position in the character sequence to serialize
    
    end - The position in the character sequence to end serialization (this position is not serialized)
    
    Returns:
    
    Returns the serialized length
  - putASCIICharSequence
```
public static final int putASCIICharSequence(long addr,
                                             int offset,
                                             CharSequence val)
```
    Serialize a character sequence to a specific memory location encoded as ASCII
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the sequence
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the sequence
    
    val - The character sequence to serialize
  - getASCIICharSequence
```
public static final String getASCIICharSequence(long addr,
                                                int offset,
                                                int len)
```
    Deserialize a character sequence encoded as ASCII at a specific memory location as a string value
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    len - The length of the string
    
    Returns:
    
    The string value
  - putUTF8CharSequence
```
public static final int putUTF8CharSequence(long addr,
                                            int offset,
                                            CharSequence val,
                                            int start,
                                            int end)
```
    Serialize a character sequence to a specific memory location encoded as UTF-8
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the sequence
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the sequence
    
    val - The character sequence to serialize
    
    start - The first position in the character sequence to serialize
    
    end - The position in the character sequence to end serialization (this position is not serialized)
    
    Returns:
    
    Returns the serialized length
  - putUTF8CharSequence
```
public static final int putUTF8CharSequence(long addr,
                                            int offset,
                                            CharSequence val)
```
    Serialize a character sequence to a specific memory location encoded as UTF-8
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the sequence
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the sequence
    
    val - The character sequence to serialize
    
    Returns:
    
    Returns the serialized length
  - getUTF8CharSequence
```
public static final String getUTF8CharSequence(long addr,
                                               int offset,
                                               int len)
```
    Deserialize a character sequence encoded as UTF-8 at a specific memory location as a string value
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    len - The length of the string
    
    Returns:
    
    The string value
  - varint32SerializedLength
```
public static final int varint32SerializedLength(int val)
```
    Return the serialized length of a 32-bit value serialized as a varint
    
    Parameters:
    
    val - The value whose varint serialized length to return
    
    Returns:
    
    The serialized length of the value serialized as a varint
  - putVarint32
```
public static final int putVarint32(long addr,
                                    int offset,
                                    int val)
```
    Serialize an integer value as a 32-bit varint to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The integer value to serialize
    
    Returns:
    
    Returns the serialized length
  - getVarint32
```
public static final int getVarint32(long addr,
                                    int offset,
                                    IOBuffer.VarintDeserializeLength deserializeLength)
```
    Deserialize an integer value serialized as a 32-bit varint from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    deserializeLength - The container of the number of bytes deserialized
    
    Returns:
    
    The int value.
  - varint64SerializedLength
```
public static final int varint64SerializedLength(long val)
```
    Return the serialized length of a 64-bit value serialized as a varint
    
    Parameters:
    
    val - The value whose varint serialized length to return
    
    Returns:
    
    The serialized length of the value serialized as a varint
  - putVarint64
```
public static final int putVarint64(long addr,
                                    int offset,
                                    long val)
```
    Serialize a long value as a 64-bit varint to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the value
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the value
    
    val - The long value to serialize
    
    Returns:
    
    Returns the serialized length
  - getVarint64
```
public static final long getVarint64(long addr,
                                     int offset,
                                     IOBuffer.VarintDeserializeLength deserializeLength)
```
    Deserialize a long value serialized as a 64-bit varint from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the value
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the value
    
    deserializeLength - The container of the number of bytes deserialized
    
    Returns:
    
    The long value.
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 byte[] array,
                                 int arrayoffset,
                                 int numelem)
```
    Serialize a section of a byte array to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               byte[] array,
                               int arrayoffset,
                               int numelem)
```
    Deserialize a section of a byte array from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 short[] array,
                                 int arrayoffset,
                                 int numelem)
```
    Serialize a section of a short array to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               short[] array,
                               int arrayoffset,
                               int numelem)
```
    Deserialize a section of a short array from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 char[] array,
                                 int arrayoffset,
                                 int numelem)
```
    Serialize a section of a char array to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               char[] array,
                               int arrayoffset,
                               int numelem)
```
    Deserialize a section of a char array from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 int[] array,
                                 int arrayoffset,
                                 int numelem)
```
    Serialize a section of an integer array to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               int[] array,
                               int arrayoffset,
                               int numelem)
```
    Deserialize a section of an int array from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 float[] array,
                                 int arrayoffset,
                                 int numelem)
```
    Serialize a section of a float array to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               float[] array,
                               int arrayoffset,
                               int numelem)
```
    Deserialize a section of a float array from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 long[] array,
                                 int arrayoffset,
                                 int numelem)
```
    Serialize a section of a long array to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               long[] array,
                               int arrayoffset,
                               int numelem)
```
    Deserialize a section of a long array from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 double[] array,
                                 int arrayoffset,
                                 int numelem)
```
    Serialize a section of a double array to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               double[] array,
                               int arrayoffset,
                               int numelem)
```
    Deserialize a section of a double array from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 ByteBuffer buffer,
                                 int bufferOffset,
                                 int len)
```
    Serialize a section of a ByteBuffer to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    buffer - The ByteBuffer to serialize from
    
    bufferOffset - The offset into the byte buffer to serialize from
    
    len - The number of bytes to serialize
  - putFrom
```
public static final void putFrom(long addr,
                                 int offset,
                                 ByteBuffer buffer)
```
    Serialize a section of a ByteBuffer to a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region in which to serialize the values
    
    offset - The offset, relative to starting address of the specified memory region, at which to serialize the values
    
    buffer - The ByteBuffer to serialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               ByteBuffer buffer,
                               int bufferOffset,
                               int len)
```
    Deserialize a section of a ByteBuffer from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    buffer - The ByteBuffer to deserialize into
    
    bufferOffset - The offset into the buffer to deserialize to
    
    len - The number of bytes to deserialize
  - getTo
```
public static final void getTo(long addr,
                               int offset,
                               ByteBuffer buffer,
                               int len)
```
    Deserialize a section of a ByteBuffer from a specific memory location
    
    Parameters:
    
    addr - The native address of the memory region from where to deserialize the values
    
    offset - The offset, relative to starting address of the specified memory region, from where to deserialize the values
    
    buffer - The ByteBuffer to deserialize into
    
    len - The number of bytes to deserialize
  - copy
```
public static final void copy(long src,
                              int srcoff,
                              long dest,
                              int destoff,
                              int len)
```
    Copy the contents of one memory region to another
    
    Parameters:
    
    src - The native address of the source memory region
    
    srcoff - The offset, relative to the starting address of the source memory, from where to copy the data
    
    dest - The native address of the destination memory region
    
    destoff - The offset, relative to starting address of the destination memory region, at which to copy the data
    
    len - The length of data to copy
  - wipe
```
public static final void wipe(long addr,
                              int addroff,
                              int len)
```
    Wipe a section of a memory region
    
    Parameters:
    
    addr - The native address of the memory region to wipe
    
    addroff - The offset, relative to the starting address of the source memory, from where to wipe the memory contents
    
    len - The number of bytes to wipe
  - dump
```
public static final String dump(long addr,
                                int offset,
                                int len)
```
    Dump the contents of a memory region.
    
    Parameters:
    
    addr - Starting address of the memory region
    
    offset - Offset into the memory region from where to start the dump
    
    len - The number of bytes to dump
    This method dumps the contents of a section of an IO buffer
  - copy
```
public final IOBuffer copy()
```
    Creates a copy of this IOBuffer.
    
    Returns:
    
    A copy of this buffer.
  - getLength
```
public final int getLength()
```
    Get the buffer length
  - getCapacity
```
public final int getCapacity()
```
    Get the buffer capacity
  - takeBuffer
```
public final ByteBuffer takeBuffer()
```
    Take an IO buffer's underlying byte buffer
    This method temporarily transfers ownership of an IO buffer's underlying byte buffer to the caller. The caller is free to manipulate the buffer markers while it has taken the buffer from the IO buffer. Once done with the buffer, the caller must call releaseBuffer() to release the buffer back to the IO buffer. While an IO buffer's byte buffer is taken from it, it will throw exceptions if any of the following methods are invoked:
    - takeBuffer() - dispose(int) - getBufferUnsafe()
  - releaseBuffer
```
public final IOBuffer releaseBuffer()
```
    Release an IO buffer's underlying buffer previously taken via takeBuffer()
    
    Returns:
    
    Returns this buffer for invocation chaining.
    This method releases an IO buffer's underlying byte buffer. This call must be preceded by a previous call to takeBuffer(). The method will reset the buffer markers. The released buffer must NOT be manipulated by the caller once released.
  - getBufferUnsafe
```
public final ByteBuffer getBufferUnsafe()
```
    Get the raw underlying byte buffer underlying an IO buffer.
    NOTE: THIS METHOD IS INTENDED FOR X PLATFORM INTERNAL USE AND SHOULD NOT BE USED. PLEASE CONSULT NEEVE TECHNICAL SUPPORT BEFORE YOU USE THIS METHOD. THIS METHOD CAN BE DEPRECATED/REMOVED/CHANGED AT ANY TIME WIHOUT NOTICE. TO DIRECTLY USE THE BUFFER UNDERLYING AN IO BUFFER (SUCH AS WITH THE JDK IO METHODS), PLEASE USE THE takeBuffer()/releaseBuffer() METHOD PAIR TO ENSURE THE BUFFER MARKERS ARE SET CORRECTLY AND THE IO BUFFER ENSURES THE UNDERLYING BUFFER IS NOT USED/MANIPULATED WHILE TEMPORARILY TAKEN FROM THE IO BUFFER FOR USE.
  - getBuffer
```
@Deprecated
public final ByteBuffer getBuffer()
```
    Deprecated. This method has been deprecated in favor of takeBuffer() and releaseBuffer()
    
    Get the underlying byte buffer.
  - getIOBuffer
```
@Deprecated
public final IOBuffer getIOBuffer()
```
    Deprecated.
    
    Return this object
    This method is only provided to ease migration from an xbuf encoding to xbuf2 encoding e.g. to allow code such as getBackingBuffer().getIOBuffer().getBufferUnsafe() to work unchanged with xbuf2
  - getNativeAddress
```
public final long getNativeAddress()
```
    Get the native address of the buffer's underlying storage
    
    Returns:
    
    Returns 0 if on-heap buffer
  - setNoWipe
```
public final IOBuffer setNoWipe()
```
    Set to not wipe an IO buffer on dispose
    By default, an IO buffer is wiped clean when disposed. Calling this method results in the buffer not to be wiped clean on disposed.
  - putByte
```
public final void putByte(int offset,
                          byte val)
```
    Serialize a byte value to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the byte value
    
    val - The value to serialize
  - getByte
```
public final byte getByte(int offset)
```
    Deserialize a byte value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the byte value
  - getUnsignedByte
```
public final int getUnsignedByte(int offset)
```
    Deserialize an unsigned byte value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the byte value
  - putShort
```
public final void putShort(int offset,
                           short val)
```
    Serialize a short value to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the short value
    
    val - The value to serialize
  - getShort
```
public final short getShort(int offset)
```
    Deserialize a short value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the short value
  - getUnsignedShort
```
public final int getUnsignedShort(int offset)
```
    Deserialize an unsigned short value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the short value
  - putChar
```
public final void putChar(int offset,
                          char val)
```
    Serialize a char value to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the char value
    
    val - The value to serialize
  - putASCIIChar
```
public final int putASCIIChar(int offset,
                              char val)
```
    Serialize a char value to an IO buffer using ASCII encoding
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the char value
    
    val - The value to serialize
  - putUTF8Char
```
public final int putUTF8Char(int offset,
                             char val)
```
    Serialize a char value to an IO buffer using UTF8 encoding
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the char value
    
    val - The value to serialize
  - getChar
```
public final char getChar(int offset)
```
    Deserialize a char value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the char value
  - getASCIIChar
```
public final char getASCIIChar(int offset)
```
    Deserialize a char value from an IO buffer serialized using ASCII encoding
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the char value
  - putInt
```
public final void putInt(int offset,
                         int val)
```
    Serialize an int value to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the int value
    
    val - The value to serialize
  - getInt
```
public final int getInt(int offset)
```
    Deserialize an int value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the int value
  - getUnsignedInt
```
public final long getUnsignedInt(int offset)
```
    Deserialize an unsigned int value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the int value
  - putFloat
```
public final void putFloat(int offset,
                           float val)
```
    Serialize a float value to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the float value
    
    val - The value to serialize
  - getFloat
```
public final float getFloat(int offset)
```
    Deserialize a float value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the float value
  - putLong
```
public final void putLong(int offset,
                          long val)
```
    Serialize a long value to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the byte value
    
    val - The value to serialize
  - putLongAsASCIICharSequence
```
public final int putLongAsASCIICharSequence(int offset,
                                            long val)
```
    Serialize a long value to an IO buffer as an ASCII character sequence
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the long value
    
    val - The value to serialize
  - getLong
```
public final long getLong(int offset)
```
    Deserialize a long value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the long value
  - getLongFromASCIICharSequence
```
public final long getLongFromASCIICharSequence(int offset,
                                               char terminationMarker,
                                               int limit,
                                               IOBuffer.ParsedCount parsedCount)
```
    Get a long value serialized as an ASCII sequence
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the long value
    
    terminationMarker - The marker character that terminates where the long value ends
    
    limit - The position at which the memory region becomes invalid
  - putDouble
```
public final void putDouble(int offset,
                            double val)
```
    Serialize a double value to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the double value
    
    val - The value to serialize
  - putDoubleAsASCIICharSequence
```
public final int putDoubleAsASCIICharSequence(int offset,
                                              double val,
                                              int precision)
```
    Serialize a double value to an IO buffer as an ASCII character sequence
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the double value
    
    val - The value to serialize
  - getDouble
```
public final double getDouble(int offset)
```
    Deserialize a double value from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the double value
  - getDoubleFromASCIICharSequence
```
public final double getDoubleFromASCIICharSequence(int offset)
```
    Deserialize a double value from an IO buffer serialized as an ASCII sequence
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the double value
  - putASCIICharSequence
```
public final int putASCIICharSequence(int offset,
                                      CharSequence val,
                                      int start,
                                      int end)
```
    Serialize a character sequence to an IO buffer using ASCII encoding
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the character sequence
    
    val - The character sequence to serialize
    
    start - The first position in the character sequence to serialize
    
    end - The end position in the character sequence to serialize (this position is not serialized)
  - putASCIICharSequence
```
public final int putASCIICharSequence(int offset,
                                      CharSequence val)
```
    Serialize a character sequence to an IO buffer using ASCII encoding
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the character sequence
    
    val - The character sequence to serialize
  - getASCIICharSequence
```
public final String getASCIICharSequence(int offset,
                                         int len)
```
    Deserialize a character sequence from an IO buffer serialized using ASCII encoding
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the value
    
    len - The length of the sequence
    
    Returns:
    
    The sequence returned as a string value
  - putUTF8CharSequence
```
public final int putUTF8CharSequence(int offset,
                                     CharSequence val,
                                     int utflen,
                                     int start,
                                     int end)
```
    Serialize a character sequence to an IO buffer using UTF-8 encoding
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the character sequence
    
    val - The character sequence to serialize
    
    utflen - The UTF-8 length of the character sequence.
    
    start - The first position in the character sequence to serialize
    
    end - The end position in the character sequence to serialize (this position is not serialized)
  - putUTF8CharSequence
```
public final int putUTF8CharSequence(int offset,
                                     CharSequence val,
                                     int start,
                                     int end)
```
    Serialize a character sequence to an IO buffer using UTF-8 encoding
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the character sequence
    
    val - The character sequence to serialize
    
    start - The first position in the character sequence to serialize
    
    end - The end position in the character sequence to serialize (this position is not serialized)
  - putUTF8CharSequence
```
public final int putUTF8CharSequence(int offset,
                                     CharSequence val)
```
    Serialize a character sequence to an IO buffer using UTF-8 encoding
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the character sequence
    
    val - The character sequence to serialize
  - getUTF8CharSequence
```
public final String getUTF8CharSequence(int offset,
                                        int len)
```
    Deserialize a character sequence from an IO buffer serialized using UTF-8 encoding
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the value
    
    len - The length of the sequence
    
    Returns:
    
    The sequence returned as a string value
  - putVarint32
```
public final void putVarint32(int offset,
                              int val)
```
    Serialize an int value to an IO buffer as a 32-bit varint
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the int value
    
    val - The value to serialize
  - getVarint32
```
public final int getVarint32(int offset,
                             IOBuffer.VarintDeserializeLength deserializeLength)
```
    Deserialize an int value from an IO buffer serialized as a 32-bit varint
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the int value
    
    deserializeLength - The container of the number of bytes deserialized
  - putVarint64
```
public final void putVarint64(int offset,
                              long val)
```
    Serialize a long value to an IO buffer as a 64-bit varint
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the long value
    
    val - The value to serialize
  - getVarint64
```
public final long getVarint64(int offset,
                              IOBuffer.VarintDeserializeLength deserializeLength)
```
    Deserialize a long value from an IO buffer serialized as a 64-bit varint
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the long value
    
    deserializeLength - The container of the number of bytes deserialized
  - putFrom
```
public final void putFrom(int offset,
                          byte[] array,
                          int arrayoffset,
                          int numelem)
```
    Serialize a section of a byte array to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public final void getTo(int offset,
                        byte[] array,
                        int arrayoffset,
                        int numelem)
```
    Deserialize a section of a byte array from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public final void putFrom(int offset,
                          short[] array,
                          int arrayoffset,
                          int numelem)
```
    Serialize a section of a short array to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public final void getTo(int offset,
                        short[] array,
                        int arrayoffset,
                        int numelem)
```
    Deserialize a section of a short array from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public final void putFrom(int offset,
                          char[] array,
                          int arrayoffset,
                          int numelem)
```
    Serialize a section of a char array to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public final void getTo(int offset,
                        char[] array,
                        int arrayoffset,
                        int numelem)
```
    Deserialize a section of a char array from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public final void putFrom(int offset,
                          int[] array,
                          int arrayoffset,
                          int numelem)
```
    Serialize a section of a int array to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public final void getTo(int offset,
                        int[] array,
                        int arrayoffset,
                        int numelem)
```
    Deserialize a section of a int array from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public final void putFrom(int offset,
                          float[] array,
                          int arrayoffset,
                          int numelem)
```
    Serialize a section of a float array to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public final void getTo(int offset,
                        float[] array,
                        int arrayoffset,
                        int numelem)
```
    Deserialize a section of a float array from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public final void putFrom(int offset,
                          long[] array,
                          int arrayoffset,
                          int numelem)
```
    Serialize a section of a long array to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public final void getTo(int offset,
                        long[] array,
                        int arrayoffset,
                        int numelem)
```
    Deserialize a section of a long array from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public final void putFrom(int offset,
                          double[] array,
                          int arrayoffset,
                          int numelem)
```
    Serialize a section of a double array to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to serialize the values
    
    array - The array to serialize
    
    arrayoffset - The offset, into the array, from where to serialize
    
    numelem - The number of array elements to serialize
  - getTo
```
public final void getTo(int offset,
                        double[] array,
                        int arrayoffset,
                        int numelem)
```
    Deserialize a section of a double array from an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to deserialize the values
    
    array - The array to deserialize
    
    arrayoffset - The offset, into the array, to deserialize into
    
    numelem - The number of array elements to deserialize
  - putFrom
```
public final void putFrom(int offset,
                          long addr,
                          int addroffset,
                          int len)
```
    Copy a section of a memory region to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer at which to copy the data
    
    addr - The native address of the start of the memory region
    
    addroffset - The offset, into the memory region, from where to copy the data
    
    len - The data length to copy
  - getTo
```
public final void getTo(int offset,
                        long addr,
                        int addroffset,
                        int len)
```
    Copy a section of an IO buffer to a memory region
    
    Parameters:
    
    offset - The offset into the buffer from where to copy the data
    
    addr - The native address of the start of the memory region
    
    addroffset - The offset, into the memory region, to copy the data to
    
    len - The data length to copy
  - putFrom
```
public final void putFrom(int offset,
                          ByteBuffer src,
                          int bufferOffset,
                          int len)
```
    Copy the data from a ByteBuffer to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer to copy the data to
    
    src - The source buffer
    
    bufferOffset - The offset into the buffer to copy from
    
    len - The number of bytes to copy
  - putFrom
```
public final void putFrom(int offset,
                          ByteBuffer src)
```
    Copy the data from a ByteBuffer to an IO buffer
    
    Parameters:
    
    offset - The offset into the buffer to copy the data to
    
    src - The source buffer
  - getTo
```
public final void getTo(int offset,
                        ByteBuffer dest,
                        int bufferOffset,
                        int len)
```
    Copy the data from an IO buffer to a ByteBuffer
    
    Parameters:
    
    offset - The offset into the IO buffer to copy the data from
    
    dest - The target buffer
    
    bufferOffset - The offset into the buffer to copy to
    
    len - The number of bytes to copy
  - getTo
```
public final void getTo(int offset,
                        ByteBuffer dest,
                        int len)
```
    Copy the data from an IO buffer to a ByteBuffer
    
    Parameters:
    
    offset - The offset into the IO buffer to copy the data from
    
    dest - The target buffer
    
    len - The number of bytes to copy
  - putFrom
```
public final void putFrom(int offset,
                          IOBuffer src,
                          int srcoff,
                          int len)
```
    Copy the contents of a section of an IO buffer to another IO buffer
    
    Parameters:
    
    offset - The offset into the buffer to copy the data to
    
    src - The source buffer
    
    srcoff - The offset into the source buffer from where to copy the data
    
    len - The length of data to copy
  - getTo
```
public final void getTo(int offset,
                        IOBuffer dest,
                        int destoff,
                        int len)
```
    Copy the contents of a section of an IO buffer to another IO buffer
    
    Parameters:
    
    offset - The offset into the buffer from where to copy the data
    
    dest - The destinaton buffer
    
    destoff - The offset into the destination buffer at which to copy the data
    
    len - The length of data to copy
  - acquire
```
public final IOBuffer acquire()
```
    Acquire a reference to an IO buffer
    This method increments an IO buffer's ownership count. Buffer ownership is used in conjunction with managing buffer pools. If a buffer is tagged to an object pool, the buffer is released back to the pool by dispose(int) when the ownership count reduces to 0. If not tagged to a pool, change of ownership count has no side effects.
    
    A buffer's ownership count starts at 1.
  - getOwnerCount
```
public final int getOwnerCount()
```
    Get an IO buffer's ownership count.
  - dispose
```
public final void dispose(int highwater)
```
    Dispose of an IO buffer.
    
    Parameters:
    
    highwater - Specifies the maximum length of the buffer that was used. This value is used to determine how much of the buffer to wipe during the pool washing process.
    This method should be invoked by the user when done with an IO buffer. It decrements the buffer's ownership count and releases it to its object pool (if one is tagged to it) and this method causes the ownership count to reduce to zero. If not tagged to a pool, ownership change methods have no side effects aside from just updating the ownership counter.
    
    Upon return from this method, the caller should assume that the buffer has been disposed and release its reference to the buffer.
  - dispose
```
public final void dispose()
```
    Dispose off an IO buffer
    This method is equivalent to dispose(this.highwater)
  - init
```
public final IOBuffer init()
```
    Implementation of UtlPool.Item#init.
    
    Specified by:
    
    init in interface UtlPool.Item<IOBuffer>
    
    Returns:
    
    Return 'this' object for method invocation chaining.
  - setPool
```
public final IOBuffer setPool(UtlPool<IOBuffer> pool)
```
    Implementation of UtlPool.Item#setPool.
    
    Specified by:
    
    setPool in interface UtlPool.Item<IOBuffer>
    
    Returns:
    
    Return 'this' object for method invocation chaining.
  - getPool
```
public final UtlPool<IOBuffer> getPool()
```
    Implementation of UtlPool.Item#getPool.
    
    Specified by:
    
    getPool in interface UtlPool.Item<IOBuffer>
    
    Returns:
    
    the pool set using UtlPool.Item.setPool(com.neeve.util.UtlPool<T>)
  - toString
```
public final String toString()
```
    Return a string representation of a buffer
    
    Overrides:
    
    toString in class Object

Class IOBuffer

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

create

createNative

wrap

allocateByteBuffer

wrapByteBuffer

wrapByteBuffer

getByteOrder

ensureCapacity

slab

slabSize

smallestSlabSize

numSlabs

allocateMemoryBlock

allocateMemoryBlock

ensureMemoryBlockCapacity

ensureMemoryBlockCapacity

freeMemoryBlock

calculateUTF8Length

calculateUTF8Length

putByte

getByte

getUnsignedByte

putShort

getShort

getUnsignedShort

putChar

putASCIIChar

putUTF8Char

getChar

getASCIIChar

putInt

getInt

getUnsignedInt

putFloat

getFloat

putLong

calcLongAsASCIICharSequenceLength

putLongAsASCIICharSequence

putLongAsASCIICharSequence

getLong

getLongFromASCIICharSequence

putDouble

putDoubleAsASCIICharSequence

putDoubleAsASCIICharSequence

getDouble

getDoubleFromASCIICharSequence

putASCIICharSequence

putASCIICharSequence

getASCIICharSequence

putUTF8CharSequence

putUTF8CharSequence

getUTF8CharSequence

varint32SerializedLength

putVarint32

getVarint32

varint64SerializedLength

putVarint64

getVarint64

putFrom

getTo

putFrom

getTo

putFrom

getTo

putFrom

getTo

putFrom

getTo

putFrom

getTo

putFrom

getTo

putFrom

putFrom

getTo