FastByteBuffer (dataset 8.1.1 API)

java.lang.Object
- de.gsi.dataset.serializer.spi.FastByteBuffer

All Implemented Interfaces:

IoBuffer, IoBufferHeader<IoBuffer>
```
public class FastByteBuffer
extends Object
implements IoBuffer
```
FastByteBuffer implementation based on JVM 'Unsafe' Class. based on: https://mechanical-sympathy.blogspot.com/2012/07/native-cc-like-performance-for-java.html http://java-performance.info/various-methods-of-binary-serialization-in-java/

Author:

rstein

Field Summary

Fields
Modifier and Type	Field and Description
`static long`	`SIZE_OF_BOOLEAN`
`static long`	`SIZE_OF_BYTE`
`static long`	`SIZE_OF_CHAR`
`static long`	`SIZE_OF_DOUBLE`
`static long`	`SIZE_OF_FLOAT`
`static long`	`SIZE_OF_INT`
`static long`	`SIZE_OF_LONG`
`static long`	`SIZE_OF_SHORT`

Constructor Summary

Constructors
Constructor and Description
`FastByteBuffer()` construct new FastByteBuffer
`FastByteBuffer(byte[] buffer, int limit)` construct new FastByteBuffer
`FastByteBuffer(int size)` construct new FastByteBuffer

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`int`	`capacity()`
`IoBuffer`	`clear()` Clears this buffer.
`static void`	`copyMemory(Object srcBase, long srcOffset, Object destBase, long destOffset, long nBytes)`
`byte[]`	`elements()`
`IoBuffer`	`ensureAdditionalCapacity(long capacity)`
`IoBuffer`	`ensureCapacity(long newCapacity)`
`IoBuffer`	`forceCapacity(long length, long preserve)` Forces FastByteBUffer to contain the given number of entries, preserving just a part of the array.
`boolean`	`getBoolean()`
`boolean[]`	`getBooleanArray(boolean[] dst, long offset, int length)`
`byte`	`getByte()`
`byte[]`	`getByteArray(byte[] dst, long offset, int length)`
`char`	`getChar()`
`char[]`	`getCharArray(char[] dst, long offset, int length)`
`double`	`getDouble()`
`double[]`	`getDoubleArray(double[] dst, long offset, int length)`
`float`	`getFloat()`
`float[]`	`getFloatArray(float[] dst, long offset, int length)`
`int`	`getInt()`
`int[]`	`getIntArray(int[] dst, long offset, int length)`
`long`	`getLong()`
`long[]`	`getLongArray(long[] dst, long offset, int length)`
`short`	`getShort()`
`short[]`	`getShortArray(short[] dst, long offset, int length)`
`String`	`getString()`
`String[]`	`getStringArray(String[] dst, long offset, int length)`
`boolean`	`hasRemaining()`
`boolean`	`isReadOnly()`
`long`	`limit()`
`IoBuffer`	`limit(int newLimit)` Sets this buffer's limit.
`ReadWriteLock`	`lock()` For efficiency/performance reasons the buffer implementation is not required to safe-guard each put/get method independently.
`long`	`position()`
`IoBuffer`	`position(long newPosition)` Sets this buffer's position.
`IoBuffer`	`putBoolean(boolean value)`
`IoBuffer`	`putBooleanArray(boolean[] values, long offset, int nToCopy)`
`IoBuffer`	`putByte(byte value)`
`IoBuffer`	`putByteArray(byte[] values, long offset, int nToCopy)`
`IoBuffer`	`putChar(char value)`
`IoBuffer`	`putCharArray(char[] values, long offset, int nToCopy)`
`IoBuffer`	`putDouble(double value)`
`IoBuffer`	`putDoubleArray(double[] values, long offset, int nToCopy)`
`IoBuffer`	`putFloat(float value)`
`IoBuffer`	`putFloatArray(float[] values, long offset, int nToCopy)`
`IoBuffer`	`putInt(int value)`
`IoBuffer`	`putIntArray(int[] values, long offset, int nToCopy)`
`IoBuffer`	`putLong(long value)`
`IoBuffer`	`putLongArray(long[] values, long offset, int nToCopy)`
`IoBuffer`	`putShort(short value)`
`IoBuffer`	`putShortArray(short[] values, long offset, int nToCopy)`
`IoBuffer`	`putString(String string)`
`IoBuffer`	`putStringArray(String[] values, long offset, int nToCopy)`
`long`	`remaining()`
`IoBuffer`	`reset()` resets the buffer read/write position to zero
`IoBuffer`	`trim()` Trims the internal buffer array so that the capacity is equal to the size.
`IoBuffer`	`trim(int requestedCapacity)` Trims the internal buffer array if it is too large.
`static FastByteBuffer`	`wrap(byte[] byteArray)` Wraps a given byte array into FastByteBuffer
`static FastByteBuffer`	`wrap(byte[] byteArray, int length)` Wraps a given byte array into FastByteBuffer

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

Methods inherited from interface de.gsi.dataset.serializer.IoBuffer
getBooleanArray, getBooleanArray, getByteArray, getByteArray, getCharArray, getCharArray, getDoubleArray, getDoubleArray, getFloatArray, getFloatArray, getIntArray, getIntArray, getLongArray, getLongArray, getShortArray, getShortArray, getStringArray, getStringArray, putBooleanArray, putBooleanArray, putByteArray, putByteArray, putCharArray, putCharArray, putDoubleArray, putDoubleArray, putFloatArray, putFloatArray, putIntArray, putIntArray, putLongArray, putLongArray, putShortArray, putShortArray, putStringArray, putStringArray

- Field Detail
  - SIZE_OF_BOOLEAN
```
public static final long SIZE_OF_BOOLEAN
```
    See Also:
    
    Constant Field Values
  - SIZE_OF_BYTE
```
public static final long SIZE_OF_BYTE
```
    See Also:
    
    Constant Field Values
  - SIZE_OF_SHORT
```
public static final long SIZE_OF_SHORT
```
    See Also:
    
    Constant Field Values
  - SIZE_OF_CHAR
```
public static final long SIZE_OF_CHAR
```
    See Also:
    
    Constant Field Values
  - SIZE_OF_INT
```
public static final long SIZE_OF_INT
```
    See Also:
    
    Constant Field Values
  - SIZE_OF_LONG
```
public static final long SIZE_OF_LONG
```
    See Also:
    
    Constant Field Values
  - SIZE_OF_FLOAT
```
public static final long SIZE_OF_FLOAT
```
    See Also:
    
    Constant Field Values
  - SIZE_OF_DOUBLE
```
public static final long SIZE_OF_DOUBLE
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - FastByteBuffer
```
public FastByteBuffer()
```
    construct new FastByteBuffer
  - FastByteBuffer
```
public FastByteBuffer(byte[] buffer,
                      int limit)
```
    construct new FastByteBuffer
    
    Parameters:
    
    buffer - buffer to initialise/re-use
    
    limit - position until buffer is filled
  - FastByteBuffer
```
public FastByteBuffer(int size)
```
    construct new FastByteBuffer
    
    Parameters:
    
    size - initial capacity of the buffer
- Method Detail
  - capacity
```
public int capacity()
```
    Specified by:
    
    capacity in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    the capacity of this buffer
  - clear
```
public IoBuffer clear()
```
    Description copied from interface: IoBufferHeader
    Clears this buffer. The position is set to zero amd the limit is set to the capacity.
    Invoke this method before using a sequence of channel-read or put operations to fill this buffer. For example:
    buf.clear(); // Prepare buffer for reading in.read(buf); // Read data
    This method does not actually erase the data in the buffer, but it is named as if it did because it will most often be used in situations in which that might as well be the case.
    Specified by:
    
    clear in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    itself (fluent design)
  - elements
```
public byte[] elements()
```
  - ensureAdditionalCapacity
```
public IoBuffer ensureAdditionalCapacity(long capacity)
```
    Specified by:
    
    ensureAdditionalCapacity in interface IoBufferHeader<IoBuffer>
  - ensureCapacity
```
public IoBuffer ensureCapacity(long newCapacity)
```
    Specified by:
    
    ensureCapacity in interface IoBufferHeader<IoBuffer>
  - forceCapacity
```
public IoBuffer forceCapacity(long length,
                              long preserve)
```
    Forces FastByteBUffer to contain the given number of entries, preserving just a part of the array.
    
    Specified by:
    
    forceCapacity in interface IoBufferHeader<IoBuffer>
    
    Parameters:
    
    length - the new minimum length for this array.
    
    preserve - the number of elements of the old buffer that shall be preserved in case a new allocation is necessary.
    
    Returns:
    
    itself (fluent design)
  - getBoolean
```
public boolean getBoolean()
```
    Specified by:
    
    getBoolean in interface IoBuffer
  - getBooleanArray
```
public boolean[] getBooleanArray(boolean[] dst,
                                 long offset,
                                 int length)
```
    Specified by:
    
    getBooleanArray in interface IoBuffer
  - getByte
```
public byte getByte()
```
    Specified by:
    
    getByte in interface IoBuffer
  - getByteArray
```
public byte[] getByteArray(byte[] dst,
                           long offset,
                           int length)
```
    Specified by:
    
    getByteArray in interface IoBuffer
  - getChar
```
public char getChar()
```
    Specified by:
    
    getChar in interface IoBuffer
  - getCharArray
```
public char[] getCharArray(char[] dst,
                           long offset,
                           int length)
```
    Specified by:
    
    getCharArray in interface IoBuffer
  - getDouble
```
public double getDouble()
```
    Specified by:
    
    getDouble in interface IoBuffer
  - getDoubleArray
```
public double[] getDoubleArray(double[] dst,
                               long offset,
                               int length)
```
    Specified by:
    
    getDoubleArray in interface IoBuffer
  - getFloat
```
public float getFloat()
```
    Specified by:
    
    getFloat in interface IoBuffer
  - getFloatArray
```
public float[] getFloatArray(float[] dst,
                             long offset,
                             int length)
```
    Specified by:
    
    getFloatArray in interface IoBuffer
  - getInt
```
public int getInt()
```
    Specified by:
    
    getInt in interface IoBuffer
  - getIntArray
```
public int[] getIntArray(int[] dst,
                         long offset,
                         int length)
```
    Specified by:
    
    getIntArray in interface IoBuffer
  - getLong
```
public long getLong()
```
    Specified by:
    
    getLong in interface IoBuffer
  - getLongArray
```
public long[] getLongArray(long[] dst,
                           long offset,
                           int length)
```
    Specified by:
    
    getLongArray in interface IoBuffer
  - getShort
```
public short getShort()
```
    Specified by:
    
    getShort in interface IoBuffer
  - getShortArray
```
public short[] getShortArray(short[] dst,
                             long offset,
                             int length)
```
    Specified by:
    
    getShortArray in interface IoBuffer
  - getString
```
public String getString()
```
    Specified by:
    
    getString in interface IoBuffer
  - getStringArray
```
public String[] getStringArray(String[] dst,
                               long offset,
                               int length)
```
    Specified by:
    
    getStringArray in interface IoBuffer
  - hasRemaining
```
public boolean hasRemaining()
```
    Specified by:
    
    hasRemaining in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    true if, and only if, there is at least one element remaining in this buffer
  - isReadOnly
```
public boolean isReadOnly()
```
    Specified by:
    
    isReadOnly in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    true if, and only if, this buffer is read-only
  - limit
```
public long limit()
```
    Specified by:
    
    limit in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    the limit of this buffer
  - limit
```
public IoBuffer limit(int newLimit)
```
    Description copied from interface: IoBufferHeader
    
    Sets this buffer's limit. If the position is larger than the new limit then it is set to the new limit. If the mark is defined and larger than the new limit then it is discarded.
    
    Specified by:
    
    limit in interface IoBufferHeader<IoBuffer>
    
    Parameters:
    
    newLimit - the new limit value; must be non-negative and no larger than this buffer's capacity
    
    Returns:
    
    itself (fluent design)
  - lock
```
public ReadWriteLock lock()
```
    Description copied from interface: IoBufferHeader
    
    For efficiency/performance reasons the buffer implementation is not required to safe-guard each put/get method independently. Thus the user-code should acquire the given lock around a set of put/get appropriately.
    
    Specified by:
    
    lock in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    the read-write lock
  - position
```
public long position()
```
    Specified by:
    
    position in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    the position of this buffer
  - position
```
public IoBuffer position(long newPosition)
```
    Description copied from interface: IoBufferHeader
    
    Sets this buffer's position. If the mark is defined and larger than the new position then it is discarded.
    
    Specified by:
    
    position in interface IoBufferHeader<IoBuffer>
    
    Parameters:
    
    newPosition - the new position value; must be non-negative and no larger than the current limit
    
    Returns:
    
    itself (fluent design)
  - putBoolean
```
public IoBuffer putBoolean(boolean value)
```
    Specified by:
    
    putBoolean in interface IoBuffer
  - putBooleanArray
```
public IoBuffer putBooleanArray(boolean[] values,
                                long offset,
                                int nToCopy)
```
    Specified by:
    
    putBooleanArray in interface IoBuffer
  - putByte
```
public IoBuffer putByte(byte value)
```
    Specified by:
    
    putByte in interface IoBuffer
  - putByteArray
```
public IoBuffer putByteArray(byte[] values,
                             long offset,
                             int nToCopy)
```
    Specified by:
    
    putByteArray in interface IoBuffer
  - putChar
```
public IoBuffer putChar(char value)
```
    Specified by:
    
    putChar in interface IoBuffer
  - putCharArray
```
public IoBuffer putCharArray(char[] values,
                             long offset,
                             int nToCopy)
```
    Specified by:
    
    putCharArray in interface IoBuffer
  - putDouble
```
public IoBuffer putDouble(double value)
```
    Specified by:
    
    putDouble in interface IoBuffer
  - putDoubleArray
```
public IoBuffer putDoubleArray(double[] values,
                               long offset,
                               int nToCopy)
```
    Specified by:
    
    putDoubleArray in interface IoBuffer
  - putFloat
```
public IoBuffer putFloat(float value)
```
    Specified by:
    
    putFloat in interface IoBuffer
  - putFloatArray
```
public IoBuffer putFloatArray(float[] values,
                              long offset,
                              int nToCopy)
```
    Specified by:
    
    putFloatArray in interface IoBuffer
  - putInt
```
public IoBuffer putInt(int value)
```
    Specified by:
    
    putInt in interface IoBuffer
  - putIntArray
```
public IoBuffer putIntArray(int[] values,
                            long offset,
                            int nToCopy)
```
    Specified by:
    
    putIntArray in interface IoBuffer
  - putLong
```
public IoBuffer putLong(long value)
```
    Specified by:
    
    putLong in interface IoBuffer
  - putLongArray
```
public IoBuffer putLongArray(long[] values,
                             long offset,
                             int nToCopy)
```
    Specified by:
    
    putLongArray in interface IoBuffer
  - putShort
```
public IoBuffer putShort(short value)
```
    Specified by:
    
    putShort in interface IoBuffer
  - putShortArray
```
public IoBuffer putShortArray(short[] values,
                              long offset,
                              int nToCopy)
```
    Specified by:
    
    putShortArray in interface IoBuffer
  - putString
```
public IoBuffer putString(String string)
```
    Specified by:
    
    putString in interface IoBuffer
  - putStringArray
```
public IoBuffer putStringArray(String[] values,
                               long offset,
                               int nToCopy)
```
    Specified by:
    
    putStringArray in interface IoBuffer
  - remaining
```
public long remaining()
```
    Specified by:
    
    remaining in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    the number of elements remaining in this buffer
  - reset
```
public IoBuffer reset()
```
    Description copied from interface: IoBufferHeader
    
    resets the buffer read/write position to zero
    
    Specified by:
    
    reset in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    itself (fluent design)
  - trim
```
public IoBuffer trim()
```
    Trims the internal buffer array so that the capacity is equal to the size.
    
    Specified by:
    
    trim in interface IoBufferHeader<IoBuffer>
    
    Returns:
    
    itself (fluent design)
    
    See Also:
    
    ArrayList.trimToSize()
  - trim
```
public IoBuffer trim(int requestedCapacity)
```
    Trims the internal buffer array if it is too large. If the current array length is smaller than or equal to n, this method does nothing. Otherwise, it trims the array length to the maximum between requestedCapacity and capacity().
    This method is useful when reusing FastBuffers. Clearing a list leaves the array length untouched. If you are reusing a list many times, you can call this method with a typical size to avoid keeping around a very large array just because of a few large transient lists.
    
    Specified by:
    
    trim in interface IoBufferHeader<IoBuffer>
    
    Parameters:
    
    requestedCapacity - the threshold for the trimming.
    
    Returns:
    
    itself (fluent design)
  - copyMemory
```
public static void copyMemory(Object srcBase,
                              long srcOffset,
                              Object destBase,
                              long destOffset,
                              long nBytes)
```
  - wrap
```
public static FastByteBuffer wrap(byte[] byteArray)
```
    Wraps a given byte array into FastByteBuffer
    Note it is guaranteed that the type of the array returned by elements() will be the same.
    
    Parameters:
    
    byteArray - an array to wrap.
    
    Returns:
    
    a new FastByteBuffer of the given size, wrapping the given array.
  - wrap
```
public static FastByteBuffer wrap(byte[] byteArray,
                                  int length)
```
    Wraps a given byte array into FastByteBuffer
    Note it is guaranteed that the type of the array returned by elements() will be the same.
    
    Parameters:
    
    byteArray - an array to wrap.
    
    length - the length of the resulting array list.
    
    Returns:
    
    a new FastByteBuffer of the given size, wrapping the given array.

Class FastByteBuffer

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Methods inherited from interface de.gsi.dataset.serializer.IoBuffer

Field Detail

SIZE_OF_BOOLEAN

SIZE_OF_BYTE

SIZE_OF_SHORT

SIZE_OF_CHAR

SIZE_OF_INT

SIZE_OF_LONG

SIZE_OF_FLOAT

SIZE_OF_DOUBLE

Constructor Detail

FastByteBuffer

FastByteBuffer

FastByteBuffer

Method Detail

capacity

clear

elements

ensureAdditionalCapacity

ensureCapacity

forceCapacity

getBoolean

getBooleanArray

getByte

getByteArray

getChar

getCharArray

getDouble

getDoubleArray

getFloat

getFloatArray

getInt

getIntArray

getLong

getLongArray

getShort

getShortArray

getString

getStringArray

hasRemaining

isReadOnly

limit

limit

lock

position

position

putBoolean

putBooleanArray

putByte

putByteArray

putChar

putCharArray

putDouble

putDoubleArray

putFloat

putFloatArray

putInt

putIntArray

putLong

putLongArray

putShort

putShortArray

putString

putStringArray

remaining

reset

trim

trim

copyMemory

wrap

wrap