one.microstream.persistence.binary.types

Class Binary

java.lang.Object

one.microstream.persistence.binary.types.Binary

All Implemented Interfaces:

Chunk

Direct Known Subclasses:

BinaryLoadItem, ChunksBuffer, ChunksWrapper

public abstract class Binary
extends Object
implements Chunk

Method Summary

Modifier and Type	Method and Description
static long	binaryListMaximumLength()
static long	binaryListMinimumLength()
abstract ByteBuffer[]	buffers()
boolean[]	build_booleans()
boolean[]	build_booleans(long listOffset)
byte[]	build_bytes()
byte[]	build_bytes(long listOffset)
char[]	build_chars()
char[]	build_chars(long listOffset)
double[]	build_doubles()
double[]	build_doubles(long listOffset)
float[]	build_floats()
float[]	build_floats(long listOffset)
int[]	build_ints()
int[]	build_ints(long listOffset)
long[]	build_longs()
long[]	build_longs(long listOffset)
short[]	build_shorts()
short[]	build_shorts(long listOffset)
Boolean	buildBoolean()
Boolean	buildBoolean(long offset)
Byte	buildByte()
Byte	buildByte(long offset)
Character	buildCharacter()
Character	buildCharacter(long offset)
Double	buildDouble()
Double	buildDouble(long offset)
Float	buildFloat()
Float	buildFloat(long offset)
Integer	buildInteger()
Integer	buildInteger(long offset)
Long	buildLong()
Long	buildLong(long offset)
Object	buildPrimitiveWrapper(Class<?> primitiveValueType)
Object	buildPrimitiveWrapper(Class<?> primitiveValueType, long offset)
<T extends one.microstream.collections.types.XAddingMap<String,Long>> T	buildRootMapping(T mapping)
Short	buildShort()
Short	buildShort(long offset)
String	buildString()
String	buildString(long offset)
String[]	buildStrings(long stringsListOffset)
static long	calculateBinaryLengthChars(long count)
static long	calculateReferenceListTotalBinaryLength(long count)
static long	calculateStringListContentBinaryLength(String[] strings)
abstract Binary	channelChunk(int channelIndex)
abstract int	channelCount()
void	collectElementsIntoArray(long binaryOffset, PersistenceLoadHandler handler, Object[] target)
int	collectKeyValueReferences(long binaryOffset, int length, PersistenceLoadHandler handler, BiConsumer<Object,Object> collector)
int	collectListObjectReferences(long binaryOffset, PersistenceLoadHandler handler, Consumer<Object> collector)
void	collectObjectReferences(long binaryOffset, int length, PersistenceLoadHandler handler, Consumer<Object> collector)
void	copyMemory(ByteBuffer directByteBuffer, long offset, BinaryValueSetter[] setters, long[] targetOffsets)
boolean[]	create_booleans()
boolean[]	create_booleans(long listOffset)
byte[]	create_bytes()
byte[]	create_bytes(long listOffset)
char[]	create_chars()
char[]	create_chars(long listOffset)
double[]	create_doubles()
double[]	create_doubles(long listOffset)
float[]	create_floats()
float[]	create_floats(long listOffset)
int[]	create_ints()
int[]	create_ints(long listOffset)
long[]	create_longs()
long[]	create_longs(long listOffset)
short[]	create_shorts()
short[]	create_shorts(long listOffset)
static long	entityContentLength(long entityTotalLength)
static int	entityHeaderLength()
static long	entityTotalLength(long entityContentLength)
static <T> BinaryField<T>	Field_boolean(String name, one.microstream.reflect.Getter_boolean<T> getter)
static <T> BinaryField<T>	Field_boolean(String name, one.microstream.reflect.Getter_boolean<T> getter, one.microstream.reflect.Setter_boolean<T> setter)
static <T> BinaryField<T>	Field_byte(String name, one.microstream.reflect.Getter_byte<T> getter)
static <T> BinaryField<T>	Field_byte(String name, one.microstream.reflect.Getter_byte<T> getter, one.microstream.reflect.Setter_byte<T> setter)
static <T> BinaryField<T>	Field_char(String name, one.microstream.reflect.Getter_char<T> getter)
static <T> BinaryField<T>	Field_char(String name, one.microstream.reflect.Getter_char<T> getter, one.microstream.reflect.Setter_char<T> setter)
static <T> BinaryField<T>	Field_double(String name, one.microstream.reflect.Getter_double<T> getter)
static <T> BinaryField<T>	Field_double(String name, one.microstream.reflect.Getter_double<T> getter, one.microstream.reflect.Setter_double<T> setter)
static <T> BinaryField<T>	Field_float(String name, one.microstream.reflect.Getter_float<T> getter)
static <T> BinaryField<T>	Field_float(String name, one.microstream.reflect.Getter_float<T> getter, one.microstream.reflect.Setter_float<T> setter)
static <T> BinaryField<T>	Field_int(String name, one.microstream.reflect.Getter_int<T> getter)
static <T> BinaryField<T>	Field_int(String name, one.microstream.reflect.Getter_int<T> getter, one.microstream.reflect.Setter_int<T> setter)
static <T> BinaryField<T>	Field_long(String name, one.microstream.reflect.Getter_long<T> getter)
static <T> BinaryField<T>	Field_long(String name, one.microstream.reflect.Getter_long<T> getter, one.microstream.reflect.Setter_long<T> setter)
static <T> BinaryField<T>	Field_short(String name, one.microstream.reflect.Getter_short<T> getter)
static <T> BinaryField<T>	Field_short(String name, one.microstream.reflect.Getter_short<T> getter, one.microstream.reflect.Setter_short<T> setter)
static <T,R> BinaryField<T>	Field(Class<R> referenceType, String name, one.microstream.reflect.Getter<T,R> getter)
static <T,R> BinaryField<T>	Field(Class<R> referenceType, String name, one.microstream.reflect.Getter<T,R> getter, one.microstream.reflect.Setter<T,R> setter)
long	getBinaryListElementCountUnvalidating(long listOffset)
long	getBinaryListElementCountValidating(long listOffset, long elementLength)
long	getBinaryListTotalByteLength(long listOffset)
long	getBuildItemContentLength()
long	getBuildItemObjectId()
long	getBuildItemTotalLength()
long	getBuildItemTypeId()
static long	getEntityLengthRawValue(long entityAddress)
static long	getEntityObjectIdRawValue(long entityAddress)
static long	getEntityTypeIdRawValue(long entityAddress)
Object	getHelper(Object key) Helper instances can be used as temporary additional state for the duration of the building process.
long	getListElementCount(long listStartOffset, int elementLength)
long	getListElementCountKeyValue(long listStartOffset)
long	getListElementCountReferences(long listStartOffset)
long	getLoadItemAvailableContentLength()
int	getSizedArrayElementCount(long headerOffset)
long	getSizedArrayElementsAddress(long headerOffset)
int	getSizedArrayLength(long sizedArrayOffset)
protected boolean	isDummyItem()
protected boolean	isProper()
boolean	isSwitchedByteOrder()
static boolean	isValidEntityLength(long entityLength)
static boolean	isValidGapLength(long gapLength)
abstract void	iterateChannelChunks(Consumer<? super Binary> logic)
abstract void	iterateEntityData(BinaryEntityDataReader reader)
void	iterateKeyValueEntriesReferences(long listOffset, PersistenceObjectIdAcceptor iterator)
void	iterateListElementReferences(long listOffset, PersistenceObjectIdAcceptor iterator)
static void	iterateListStructureCompositeElements(Binary data, long elementsListOffset, int elementReferencesOffset, int elementReferenceCount, int elementTrailingBytes, PersistenceReferenceLoader iterator) Usage example: For an entity solely consisting of a list of elements with each (2 ints, 1 float, 1 reference), call: iterateReferences(data, 0, 12, 1, 0, iterator). (2*4 bytes + 1*4 bytes, 1 reference, no trailing bytes)
long	iterateListStructureElements(long listOffset, BinaryElementReader reader) Iterates over all elements of a binary list.
void	iterateListStructureReferenceRange(long listOffset, int referencesPerElement, PersistenceObjectIdAcceptor iterator)
void	iterateReferenceRange(long startOffset, long boundOffset, PersistenceObjectIdAcceptor iterator)
void	iterateReferenceRangeUnvalidated(long startOffset, long boundOffset, PersistenceObjectIdAcceptor iterator)
abstract long	iterateReferences(BinaryReferenceTraverser[] traversers, PersistenceObjectIdAcceptor acceptor)
void	iterateSizedArrayElementReferences(long offset, PersistenceObjectIdAcceptor iterator)
static long	keyValueBinaryLength()
static long	keyValueReferenceCount(long elementCount)
static int	lengthLength()
abstract void	modifyLoadItem(ByteBuffer directByteBuffer, long offset, long entityTotalLength, long entityTypeId, long entityObjectId)
static int	objectIdByteLength()
boolean	read_boolean(long offset)
byte	read_byte(long offset)
char	read_char(long offset)
double	read_double(long offset)
float	read_float(long offset)
int	read_int(long offset)
long	read_long(long offset)
short	read_short(long offset)
static long	referenceBinaryLength(long referenceCount)
void	registerHelper(Object key, Object helper) Helper instances can be used as temporary additional state for the duration of the building process.
void	store_boolean(boolean value)
void	store_boolean(long offset, boolean value)
void	store_booleans(long typeId, long objectId, boolean[] array)
void	store_byte(byte value)
void	store_byte(long offset, byte value)
void	store_bytes(long typeId, long objectId, byte[] array)
void	store_char(char value)
void	store_char(long offset, char value)
void	store_chars(long typeId, long objectId, char[] array)
void	store_double(double value)
void	store_double(long offset, double value)
void	store_doubles(long typeId, long objectId, double[] array)
void	store_float(float value)
void	store_float(long offset, float value)
void	store_floats(long typeId, long objectId, float[] array)
void	store_int(int value)
void	store_int(long offset, int value)
void	store_ints(long typeId, long objectId, int[] array)
void	store_long(long value)
void	store_long(long offset, long value)
void	store_longs(long typeId, long objectId, long[] array)
void	store_short(long offset, short value)
void	store_short(short value)
void	store_shorts(long typeId, long objectId, short[] array)
void	storeBoolean(long typeId, long objectId, boolean value)
void	storeByte(long typeId, long objectId, byte value)
void	storeCharacter(long typeId, long objectId, char value)
long	storeCharsAsList(long memoryOffset, char[] chars, int offset, int length)
void	storeDouble(long typeId, long objectId, double value)
abstract void	storeEntityHeader(long entityContentLength, long entityTypeId, long entityObjectId)
void	storeFixedSize(PersistenceStoreHandler<Binary> handler, long contentLength, long typeId, long objectId, Object instance, long[] memoryOffsets, BinaryValueStorer[] storers)
void	storeFloat(long typeId, long objectId, float value)
void	storeInteger(long typeId, long objectId, int value)
void	storeIterableAsList(long tid, long oid, long headerOffset, Iterable<?> elements, long size, PersistenceFunction persister)
void	storeIterableContentAsList(long offset, PersistenceFunction persister, Iterable<?> elements, long elementCount)
void	storeKeyValuesAsEntries(long typeId, long objectId, long headerOffset, Iterable<? extends one.microstream.typing.KeyValue<?,?>> keyValues, long size, PersistenceFunction persister)
void	storeKeyValuesAsEntries(long offset, PersistenceFunction persister, Iterable<? extends one.microstream.typing.KeyValue<?,?>> elements, long elementCount)
void	storeListHeader(long offset, long elementsBinaryLength, long elementsCount)
void	storeLong(long typeId, long objectId, long value)
<K,V> void	storeMapEntrySet(long typeId, long objectId, long headerOffset, Set<Map.Entry<K,V>> entrySet, PersistenceFunction persister)
void	storeReferences(long typeId, long objectId, long binaryOffset, PersistenceFunction persister, Object[] array)
void	storeReferences(long typeId, long objectId, long binaryOffset, PersistenceFunction persister, Object[] array, int arrayOffset, int arrayLength)
void	storeReferencesAsList(long memoryOffset, PersistenceFunction persister, Object[] array, int offset, int length)
void	storeRoots(long typeId, long objectId, one.microstream.collections.types.XGettingTable<String,Object> entries, PersistenceFunction persister)
void	storeShort(long typeId, long objectId, short value)
void	storeSizedArray(long tid, long oid, long headerOffset, Object[] array, int offset, int size, PersistenceFunction persister)
void	storeSizedArray(long tid, long oid, long headerOffset, Object[] array, int size, PersistenceFunction persister)
void	storeStateless(long typeId, long objectId)
void	storeStringsAsList(long memoryOffset, long precalculatedContentBinaryLength, String[] strings)
void	storeStringsAsList(long memoryOffset, long precalculatedContentBinaryLength, String[] strings, int offset, int length)
void	storeStringSingleValue(long typeId, long objectId, char[] chars)
void	storeStringSingleValue(long typeId, long objectId, char[] chars, int offset, int length)
void	storeStringSingleValue(long typeId, long objectId, String string)
void	storeStringValue(long binaryOffset, char[] chars)
void	storeStringValue(long binaryOffset, char[] chars, int offset, int length)
void	storeStringValue(long binaryOffset, String string)
static long	toBinaryListByteLengthOffset(long binaryListOffset)
static long	toBinaryListContentByteLength(long binaryListTotalByteLength)
static long	toBinaryListElementCountOffset(long binaryListOffset)
static long	toBinaryListElementsOffset(long binaryListOffset)
static long	toBinaryListTotalByteLength(long binaryListElementsByteLength)
static long	toEntityContentOffset(long entityOffset)
static <T> BinaryTypeHandler<T>	TypeHandler(Class<T> entityType, BinaryField<? super T>... binaryFields)
static <T> BinaryTypeHandler<T>	TypeHandler(Class<T> entityType, PersistenceTypeInstantiator<Binary,T> instantiator, BinaryField<? super T>... binaryFields)
void	update_booleans(boolean[] array)
void	update_booleans(long offset, boolean[] array)
void	update_bytes(byte[] array)
void	update_bytes(long offset, byte[] array)
void	update_chars(char[] array)
void	update_chars(long offset, char[] array)
void	update_doubles(double[] array)
void	update_doubles(long offset, double[] array)
void	update_floats(float[] array)
void	update_floats(long offset, float[] array)
void	update_ints(int[] array)
void	update_ints(long offset, int[] array)
void	update_longs(long[] array)
void	update_longs(long offset, long[] array)
void	update_shorts(long offset, short[] array)
void	update_shorts(short[] array)
void	updateArrayObjectReferences(long binaryListStartOffset, PersistenceLoadHandler handler, Object[] array, int arrayOffset, int arrayLength)
void	updateArrayObjectReferences1(long binaryListStartOffset, PersistenceLoadHandler handler, Object[] array)
void	updateFixedSize(Object instance, BinaryValueSetter[] setters, long[] memoryOffsets, PersistenceLoadHandler handler)
int	updateSizedArrayObjectReferences(long binaryOffset, PersistenceLoadHandler handler, Object[] array) Updates the passed array up to the size defined by the binary data, returns the size.
void	validateArrayLength(Object[] array, long headerOffset)

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Methods inherited from interface one.microstream.persistence.binary.types.Chunk

clear, isEmpty, totalLength

Method Detail

keyValueReferenceCount

public static long keyValueReferenceCount(long elementCount)

keyValueBinaryLength

public static long keyValueBinaryLength()

binaryListMinimumLength

public static long binaryListMinimumLength()

binaryListMaximumLength

public static long binaryListMaximumLength()

toBinaryListTotalByteLength

public static long toBinaryListTotalByteLength(long binaryListElementsByteLength)

toBinaryListContentByteLength

public static long toBinaryListContentByteLength(long binaryListTotalByteLength)

lengthLength

public static int lengthLength()

Returns:

the length in bytes of a peristent item's length field (8 bytes).

isValidGapLength

public static boolean isValidGapLength(long gapLength)

isValidEntityLength

public static boolean isValidEntityLength(long entityLength)

entityHeaderLength

public static int entityHeaderLength()

entityTotalLength

public static long entityTotalLength(long entityContentLength)

entityContentLength

public static long entityContentLength(long entityTotalLength)

toEntityContentOffset

public static long toEntityContentOffset(long entityOffset)

toBinaryListByteLengthOffset

public static final long toBinaryListByteLengthOffset(long binaryListOffset)

toBinaryListElementCountOffset

public static final long toBinaryListElementCountOffset(long binaryListOffset)

toBinaryListElementsOffset

public static long toBinaryListElementsOffset(long binaryListOffset)

objectIdByteLength

public static int objectIdByteLength()

referenceBinaryLength

public static long referenceBinaryLength(long referenceCount)

calculateReferenceListTotalBinaryLength

public static long calculateReferenceListTotalBinaryLength(long count)

calculateStringListContentBinaryLength

public static long calculateStringListContentBinaryLength(String[] strings)

calculateBinaryLengthChars

public static long calculateBinaryLengthChars(long count)

getEntityLengthRawValue

public static final long getEntityLengthRawValue(long entityAddress)

getEntityTypeIdRawValue

public static final long getEntityTypeIdRawValue(long entityAddress)

getEntityObjectIdRawValue

public static final long getEntityObjectIdRawValue(long entityAddress)

buffers

public abstract ByteBuffer[] buffers()

Specified by:

buffers in interface Chunk

isSwitchedByteOrder

public boolean isSwitchedByteOrder()

getBuildItemTotalLength

public final long getBuildItemTotalLength()

getBuildItemContentLength

public final long getBuildItemContentLength()

getBuildItemTypeId

public final long getBuildItemTypeId()

getBuildItemObjectId

public final long getBuildItemObjectId()

storeEntityHeader

public abstract void storeEntityHeader(long entityContentLength,
                                       long entityTypeId,
                                       long entityObjectId)

getListElementCountKeyValue

public final long getListElementCountKeyValue(long listStartOffset)

read_byte

public final byte read_byte(long offset)

read_boolean

public final boolean read_boolean(long offset)

read_short

public final short read_short(long offset)

read_char

public final char read_char(long offset)

read_int

public final int read_int(long offset)

read_float

public final float read_float(long offset)

read_long

public final long read_long(long offset)

read_double

public final double read_double(long offset)

channelChunk

public abstract Binary channelChunk(int channelIndex)

channelCount

public abstract int channelCount()

iterateChannelChunks

public abstract void iterateChannelChunks(Consumer<? super Binary> logic)

iterateEntityData

public abstract void iterateEntityData(BinaryEntityDataReader reader)

storeKeyValuesAsEntries

public final void storeKeyValuesAsEntries(long typeId,
                                          long objectId,
                                          long headerOffset,
                                          Iterable<? extends one.microstream.typing.KeyValue<?,?>> keyValues,
                                          long size,
                                          PersistenceFunction persister)

storeMapEntrySet

public final <K,V> void storeMapEntrySet(long typeId,
                                         long objectId,
                                         long headerOffset,
                                         Set<Map.Entry<K,V>> entrySet,
                                         PersistenceFunction persister)

storeSizedArray

public final void storeSizedArray(long tid,
                                  long oid,
                                  long headerOffset,
                                  Object[] array,
                                  int size,
                                  PersistenceFunction persister)

storeSizedArray

public final void storeSizedArray(long tid,
                                  long oid,
                                  long headerOffset,
                                  Object[] array,
                                  int offset,
                                  int size,
                                  PersistenceFunction persister)

storeRoots

public final void storeRoots(long typeId,
                             long objectId,
                             one.microstream.collections.types.XGettingTable<String,Object> entries,
                             PersistenceFunction persister)

buildRootMapping

public final <T extends one.microstream.collections.types.XAddingMap<String,Long>> T buildRootMapping(T mapping)

storeIterableAsList

public final void storeIterableAsList(long tid,
                                      long oid,
                                      long headerOffset,
                                      Iterable<?> elements,
                                      long size,
                                      PersistenceFunction persister)

getSizedArrayElementCount

public int getSizedArrayElementCount(long headerOffset)

getSizedArrayLength

public final int getSizedArrayLength(long sizedArrayOffset)

getSizedArrayElementsAddress

public final long getSizedArrayElementsAddress(long headerOffset)

validateArrayLength

public final void validateArrayLength(Object[] array,
                                      long headerOffset)

getBinaryListTotalByteLength

public final long getBinaryListTotalByteLength(long listOffset)

getLoadItemAvailableContentLength

public final long getLoadItemAvailableContentLength()

getBinaryListElementCountValidating

public final long getBinaryListElementCountValidating(long listOffset,
                                                      long elementLength)

getBinaryListElementCountUnvalidating

public final long getBinaryListElementCountUnvalidating(long listOffset)

getListElementCount

public final long getListElementCount(long listStartOffset,
                                      int elementLength)

getListElementCountReferences

public final long getListElementCountReferences(long listStartOffset)

iterateListStructureElements

public final long iterateListStructureElements(long listOffset,
                                               BinaryElementReader reader)

Iterates over all elements of a binary list. All elements must have the same binary length.

Parameters:

listOffset - the binary offset at which the binary list (actually: its header) starts

reader - the reader logic to be used by the iteration.

Returns:

the element count that has been iterated.

iterateListElementReferences

public final void iterateListElementReferences(long listOffset,
                                               PersistenceObjectIdAcceptor iterator)

iterateSizedArrayElementReferences

public final void iterateSizedArrayElementReferences(long offset,
                                                     PersistenceObjectIdAcceptor iterator)

iterateListStructureReferenceRange

public final void iterateListStructureReferenceRange(long listOffset,
                                                     int referencesPerElement,
                                                     PersistenceObjectIdAcceptor iterator)

iterateListStructureCompositeElements

public static void iterateListStructureCompositeElements(Binary data,
                                                         long elementsListOffset,
                                                         int elementReferencesOffset,
                                                         int elementReferenceCount,
                                                         int elementTrailingBytes,
                                                         PersistenceReferenceLoader iterator)

Usage example:
For an entity solely consisting of a list of elements with each (2 ints, 1 float, 1 reference), call:
iterateReferences(data, 0, 12, 1, 0, iterator).
(2*4 bytes + 1*4 bytes, 1 reference, no trailing bytes)

For an entity solely consisting of a list of elements with each (1 ints, 3 reference, 1 short), call:
iterateReferences(data, 0, 4, 3, 2, iterator).
(1*4 bytes, 3 references, 1*2 trailing bytes)

Parameters:

data - the Binary instance to read the data from.

elementsListOffset - the offset in bytes where the elements list is located in the whole entity.

elementReferencesOffset - the offset in bytes where the references are located in each element.

elementReferenceCount - the amount of references in each element.

elementTrailingBytes - the number of bytes after the references in each element.

iterator - the iterator to process the reference ids.

iterateKeyValueEntriesReferences

public final void iterateKeyValueEntriesReferences(long listOffset,
                                                   PersistenceObjectIdAcceptor iterator)

iterateReferenceRange

public final void iterateReferenceRange(long startOffset,
                                        long boundOffset,
                                        PersistenceObjectIdAcceptor iterator)

iterateReferenceRangeUnvalidated

public final void iterateReferenceRangeUnvalidated(long startOffset,
                                                   long boundOffset,
                                                   PersistenceObjectIdAcceptor iterator)

store_bytes

public final void store_bytes(long typeId,
                              long objectId,
                              byte[] array)

store_booleans

public final void store_booleans(long typeId,
                                 long objectId,
                                 boolean[] array)

store_shorts

public final void store_shorts(long typeId,
                               long objectId,
                               short[] array)

store_chars

public final void store_chars(long typeId,
                              long objectId,
                              char[] array)

store_ints

public final void store_ints(long typeId,
                             long objectId,
                             int[] array)

store_floats

public final void store_floats(long typeId,
                               long objectId,
                               float[] array)

store_longs

public final void store_longs(long typeId,
                              long objectId,
                              long[] array)

store_doubles

public final void store_doubles(long typeId,
                                long objectId,
                                double[] array)

storeByte

public final void storeByte(long typeId,
                            long objectId,
                            byte value)

storeBoolean

public final void storeBoolean(long typeId,
                               long objectId,
                               boolean value)

storeShort

public final void storeShort(long typeId,
                             long objectId,
                             short value)

storeCharacter

public final void storeCharacter(long typeId,
                                 long objectId,
                                 char value)

storeInteger

public final void storeInteger(long typeId,
                               long objectId,
                               int value)

storeFloat

public final void storeFloat(long typeId,
                             long objectId,
                             float value)

storeLong

public final void storeLong(long typeId,
                            long objectId,
                            long value)

storeDouble

public final void storeDouble(long typeId,
                              long objectId,
                              double value)

storeStateless

public final void storeStateless(long typeId,
                                 long objectId)

storeStringSingleValue

public final void storeStringSingleValue(long typeId,
                                         long objectId,
                                         String string)

storeStringSingleValue

public final void storeStringSingleValue(long typeId,
                                         long objectId,
                                         char[] chars)

storeStringSingleValue

public final void storeStringSingleValue(long typeId,
                                         long objectId,
                                         char[] chars,
                                         int offset,
                                         int length)

storeStringValue

public final void storeStringValue(long binaryOffset,
                                   String string)

storeStringValue

public final void storeStringValue(long binaryOffset,
                                   char[] chars)

storeStringValue

public final void storeStringValue(long binaryOffset,
                                   char[] chars,
                                   int offset,
                                   int length)

storeReferences

public final void storeReferences(long typeId,
                                  long objectId,
                                  long binaryOffset,
                                  PersistenceFunction persister,
                                  Object[] array)

storeReferences

public final void storeReferences(long typeId,
                                  long objectId,
                                  long binaryOffset,
                                  PersistenceFunction persister,
                                  Object[] array,
                                  int arrayOffset,
                                  int arrayLength)

storeFixedSize

public final void storeFixedSize(PersistenceStoreHandler<Binary> handler,
                                 long contentLength,
                                 long typeId,
                                 long objectId,
                                 Object instance,
                                 long[] memoryOffsets,
                                 BinaryValueStorer[] storers)

buildStrings

public final String[] buildStrings(long stringsListOffset)

buildByte

public final Byte buildByte()

buildByte

public final Byte buildByte(long offset)

buildBoolean

public final Boolean buildBoolean()

buildBoolean

public final Boolean buildBoolean(long offset)

buildShort

public final Short buildShort()

buildShort

public final Short buildShort(long offset)

buildCharacter

public final Character buildCharacter()

buildCharacter

public final Character buildCharacter(long offset)

buildInteger

public final Integer buildInteger()

buildInteger

public final Integer buildInteger(long offset)

buildFloat

public final Float buildFloat()

buildFloat

public final Float buildFloat(long offset)

buildLong

public final Long buildLong()

buildLong

public final Long buildLong(long offset)

buildDouble

public final Double buildDouble()

buildDouble

public final Double buildDouble(long offset)

buildPrimitiveWrapper

public final Object buildPrimitiveWrapper(Class<?> primitiveValueType)

buildPrimitiveWrapper

public final Object buildPrimitiveWrapper(Class<?> primitiveValueType,
                                          long offset)

buildString

public final String buildString()

buildString

public final String buildString(long offset)

create_bytes

public final byte[] create_bytes()

create_bytes

public final byte[] create_bytes(long listOffset)

create_booleans

public final boolean[] create_booleans()

create_booleans

public final boolean[] create_booleans(long listOffset)

create_shorts

public final short[] create_shorts()

create_shorts

public final short[] create_shorts(long listOffset)

create_chars

public final char[] create_chars()

create_chars

public final char[] create_chars(long listOffset)

create_ints

public final int[] create_ints()

create_ints

public final int[] create_ints(long listOffset)

create_floats

public final float[] create_floats()

create_floats

public final float[] create_floats(long listOffset)

create_longs

public final long[] create_longs()

create_longs

public final long[] create_longs(long listOffset)

create_doubles

public final double[] create_doubles()

create_doubles

public final double[] create_doubles(long listOffset)

build_bytes

public final byte[] build_bytes()

build_bytes

public final byte[] build_bytes(long listOffset)

build_booleans

public final boolean[] build_booleans()

build_booleans

public final boolean[] build_booleans(long listOffset)

build_shorts

public final short[] build_shorts()

build_shorts

public final short[] build_shorts(long listOffset)

build_chars

public final char[] build_chars()

build_chars

public final char[] build_chars(long listOffset)

build_ints

public final int[] build_ints()

build_ints

public final int[] build_ints(long listOffset)

build_floats

public final float[] build_floats()

build_floats

public final float[] build_floats(long listOffset)

build_longs

public final long[] build_longs()

build_longs

public final long[] build_longs(long listOffset)

build_doubles

public final double[] build_doubles()

build_doubles

public final double[] build_doubles(long listOffset)

collectElementsIntoArray

public final void collectElementsIntoArray(long binaryOffset,
                                           PersistenceLoadHandler handler,
                                           Object[] target)

collectListObjectReferences

public final int collectListObjectReferences(long binaryOffset,
                                             PersistenceLoadHandler handler,
                                             Consumer<Object> collector)

collectObjectReferences

public final void collectObjectReferences(long binaryOffset,
                                          int length,
                                          PersistenceLoadHandler handler,
                                          Consumer<Object> collector)

collectKeyValueReferences

public final int collectKeyValueReferences(long binaryOffset,
                                           int length,
                                           PersistenceLoadHandler handler,
                                           BiConsumer<Object,Object> collector)

iterateReferences

public abstract long iterateReferences(BinaryReferenceTraverser[] traversers,
                                       PersistenceObjectIdAcceptor acceptor)

storeCharsAsList

public final long storeCharsAsList(long memoryOffset,
                                   char[] chars,
                                   int offset,
                                   int length)

copyMemory

public final void copyMemory(ByteBuffer directByteBuffer,
                             long offset,
                             BinaryValueSetter[] setters,
                             long[] targetOffsets)

storeListHeader

public final void storeListHeader(long offset,
                                  long elementsBinaryLength,
                                  long elementsCount)

storeIterableContentAsList

public final void storeIterableContentAsList(long offset,
                                             PersistenceFunction persister,
                                             Iterable<?> elements,
                                             long elementCount)

storeStringsAsList

public final void storeStringsAsList(long memoryOffset,
                                     long precalculatedContentBinaryLength,
                                     String[] strings)

storeStringsAsList

public final void storeStringsAsList(long memoryOffset,
                                     long precalculatedContentBinaryLength,
                                     String[] strings,
                                     int offset,
                                     int length)

storeKeyValuesAsEntries

public final void storeKeyValuesAsEntries(long offset,
                                          PersistenceFunction persister,
                                          Iterable<? extends one.microstream.typing.KeyValue<?,?>> elements,
                                          long elementCount)

storeReferencesAsList

public final void storeReferencesAsList(long memoryOffset,
                                        PersistenceFunction persister,
                                        Object[] array,
                                        int offset,
                                        int length)

store_byte

public final void store_byte(long offset,
                             byte value)

store_boolean

public final void store_boolean(long offset,
                                boolean value)

store_short

public final void store_short(long offset,
                              short value)

store_char

public final void store_char(long offset,
                             char value)

store_int

public final void store_int(long offset,
                            int value)

store_float

public final void store_float(long offset,
                              float value)

store_long

public final void store_long(long offset,
                             long value)

store_double

public final void store_double(long offset,
                               double value)

store_byte

public final void store_byte(byte value)

store_boolean

public final void store_boolean(boolean value)

store_short

public final void store_short(short value)

store_char

public final void store_char(char value)

store_int

public final void store_int(int value)

store_float

public final void store_float(float value)

store_long

public final void store_long(long value)

store_double

public final void store_double(double value)

isDummyItem

protected final boolean isDummyItem()

isProper

protected final boolean isProper()

modifyLoadItem

public abstract void modifyLoadItem(ByteBuffer directByteBuffer,
                                    long offset,
                                    long entityTotalLength,
                                    long entityTypeId,
                                    long entityObjectId)

updateFixedSize

public final void updateFixedSize(Object instance,
                                  BinaryValueSetter[] setters,
                                  long[] memoryOffsets,
                                  PersistenceLoadHandler handler)

updateSizedArrayObjectReferences

public final int updateSizedArrayObjectReferences(long binaryOffset,
                                                  PersistenceLoadHandler handler,
                                                  Object[] array)

Updates the passed array up to the size defined by the binary data, returns the size.

Parameters:

binaryOffset - the offset of the array size in the binary data

handler - the persistence load handler

array - the array to update

Returns:

the array size

updateArrayObjectReferences1

public final void updateArrayObjectReferences1(long binaryListStartOffset,
                                               PersistenceLoadHandler handler,
                                               Object[] array)

updateArrayObjectReferences

public final void updateArrayObjectReferences(long binaryListStartOffset,
                                              PersistenceLoadHandler handler,
                                              Object[] array,
                                              int arrayOffset,
                                              int arrayLength)

update_bytes

public final void update_bytes(byte[] array)

update_bytes

public final void update_bytes(long offset,
                               byte[] array)

update_booleans

public final void update_booleans(boolean[] array)

update_booleans

public final void update_booleans(long offset,
                                  boolean[] array)

update_shorts

public final void update_shorts(short[] array)

update_shorts

public final void update_shorts(long offset,
                                short[] array)

update_chars

public final void update_chars(char[] array)

update_chars

public final void update_chars(long offset,
                               char[] array)

update_ints

public final void update_ints(int[] array)

update_ints

public final void update_ints(long offset,
                              int[] array)

update_floats

public final void update_floats(float[] array)

update_floats

public final void update_floats(long offset,
                                float[] array)

update_longs

public final void update_longs(long[] array)

update_longs

public final void update_longs(long offset,
                               long[] array)

update_doubles

public final void update_doubles(double[] array)

update_doubles

public final void update_doubles(long offset,
                                 double[] array)

registerHelper

public final void registerHelper(Object key,
                                 Object helper)

Helper instances can be used as temporary additional state for the duration of the building process. E.g.: JDK hash collections cannot properly collect elements during the building process as the element instances might still be in an initialized state without their proper data, so hashing and equality comparisons would fail or result in all elements being "equal". So building JDK hash collections required to pre-collect their elements in an additional helper structure and defer the actual elements collecting to the completion.

Similar problems with other or complex custom handlers are conceivable.

Only one helper object can be registered per subject instance (the instance to be built).

Parameters:

key - the object to register the helper for

helper - the helper to register

getHelper

public final Object getHelper(Object key)

Helper instances can be used as temporary additional state for the duration of the building process. E.g.: JDK hash collections cannot properly collect elements during the building process as the element instances might still be in an initialized state without their proper data, so hashing and equality comparisons would failt or result in all elements being "equal". So building JDK hash collections required to pre-collect their elements in an additional helper structure and defer the actual elements collecting to the completion.

Similar problems with other or complex custom handlers are conceivable.

Parameters:

key - the object to get the helper for

Returns:

the registered helper, or null if none is registered for the key object

Field_byte

public static final <T> BinaryField<T> Field_byte(String name,
                                                  one.microstream.reflect.Getter_byte<T> getter)

Field_byte

public static final <T> BinaryField<T> Field_byte(String name,
                                                  one.microstream.reflect.Getter_byte<T> getter,
                                                  one.microstream.reflect.Setter_byte<T> setter)

Field_boolean

public static final <T> BinaryField<T> Field_boolean(String name,
                                                     one.microstream.reflect.Getter_boolean<T> getter)

Field_boolean

public static final <T> BinaryField<T> Field_boolean(String name,
                                                     one.microstream.reflect.Getter_boolean<T> getter,
                                                     one.microstream.reflect.Setter_boolean<T> setter)

Field_short

public static final <T> BinaryField<T> Field_short(String name,
                                                   one.microstream.reflect.Getter_short<T> getter)

Field_short

public static final <T> BinaryField<T> Field_short(String name,
                                                   one.microstream.reflect.Getter_short<T> getter,
                                                   one.microstream.reflect.Setter_short<T> setter)

Field_char

public static final <T> BinaryField<T> Field_char(String name,
                                                  one.microstream.reflect.Getter_char<T> getter)

Field_char

public static final <T> BinaryField<T> Field_char(String name,
                                                  one.microstream.reflect.Getter_char<T> getter,
                                                  one.microstream.reflect.Setter_char<T> setter)

Field_int

public static final <T> BinaryField<T> Field_int(String name,
                                                 one.microstream.reflect.Getter_int<T> getter)

Field_int

public static final <T> BinaryField<T> Field_int(String name,
                                                 one.microstream.reflect.Getter_int<T> getter,
                                                 one.microstream.reflect.Setter_int<T> setter)

Field_float

public static final <T> BinaryField<T> Field_float(String name,
                                                   one.microstream.reflect.Getter_float<T> getter)

Field_float

public static final <T> BinaryField<T> Field_float(String name,
                                                   one.microstream.reflect.Getter_float<T> getter,
                                                   one.microstream.reflect.Setter_float<T> setter)

Field_long

public static final <T> BinaryField<T> Field_long(String name,
                                                  one.microstream.reflect.Getter_long<T> getter)

Field_long

public static final <T> BinaryField<T> Field_long(String name,
                                                  one.microstream.reflect.Getter_long<T> getter,
                                                  one.microstream.reflect.Setter_long<T> setter)

Field_double

public static final <T> BinaryField<T> Field_double(String name,
                                                    one.microstream.reflect.Getter_double<T> getter)

Field_double

public static final <T> BinaryField<T> Field_double(String name,
                                                    one.microstream.reflect.Getter_double<T> getter,
                                                    one.microstream.reflect.Setter_double<T> setter)

Field

public static final <T,R> BinaryField<T> Field(Class<R> referenceType,
                                               String name,
                                               one.microstream.reflect.Getter<T,R> getter)

Field

public static final <T,R> BinaryField<T> Field(Class<R> referenceType,
                                               String name,
                                               one.microstream.reflect.Getter<T,R> getter,
                                               one.microstream.reflect.Setter<T,R> setter)

TypeHandler

@SafeVarargs
public static <T> BinaryTypeHandler<T> TypeHandler(Class<T> entityType,
                                                                BinaryField<? super T>... binaryFields)

TypeHandler

@SafeVarargs
public static <T> BinaryTypeHandler<T> TypeHandler(Class<T> entityType,
                                                                PersistenceTypeInstantiator<Binary,T> instantiator,
                                                                BinaryField<? super T>... binaryFields)