net.openhft.chronicle.bytes

Interface RandomDataInput

All Known Subinterfaces:

Bytes<Underlying>, BytesIn<Underlying>, BytesStore<B,Underlying>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, GuardedNativeBytes, HeapBytesStore, HexDumpBytes, MappedBytes, MappedBytesStore, NativeBytes, NativeBytes.NativeSubBytes, NativeBytesStore, NoBytesStore, OnHeapBytes, PointerBytesStore, ReadOnlyMappedBytesStore, ReleasedBytesStore, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes

public interface RandomDataInput

This allows random access to the underling bytes. This instance can be used across threads as it is stateless. The thread safety of the underlying data depends on how the methods are used.

Field Summary

Fields

Modifier and Type	Field and Description
static String[]	charToString

Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

INIT

Method Summary

Modifier and Type	Method and Description
default double	addAndGetDouble(long offset, double adding) Perform an atomic add and get operation for a 64-bit double
default float	addAndGetFloat(long offset, float adding) Perform an atomic add and get operation for a 32-bit float
default int	addAndGetInt(long offset, int adding) Perform an atomic add and get operation for a 32-bit int
default long	addAndGetLong(long offset, long adding) Perform an atomic add and get operation for a 64-bit long
long	addressForRead(long offset) Obtain the underlying addressForRead.
default long	addressForRead(long offset, int buffer)
long	addressForWrite(long offset) Obtain the underlying addressForRead.
long	addressForWritePosition()
default ByteOrder	byteOrder()
@NotNull Bytes	bytesForRead()
@NotNull Bytes	bytesForWrite()
default boolean	canReadDirect(long length)
default long	capacity()
default boolean	compareAndSwapDouble(long offset, double expected, double value) Perform a 64-bit double CAS at a given offset.
default boolean	compareAndSwapFloat(long offset, float expected, float value) Perform a 32-bit float CAS at a given offset.
boolean	compareAndSwapInt(long offset, int expected, int value) Perform a 32-bit CAS at a given offset.
boolean	compareAndSwapLong(long offset, long expected, long value) Perform a 64-bit CAS at a given offset.
default boolean	compareUtf8(long offset, @Nullable CharSequence other) Compares the UTF-8 encoded char sequence, written in this RandomDataInput at the given offset, with the given char sequence.
default int	copyTo(@NotNull byte[] bytes) Read a byte[] from memory.
default int	copyTo(@NotNull ByteBuffer bb) Copy data from this RandomDataInput to the ByteBuffer.
static @NotNull String[]	createCharToString()
default int	fastHash(long offset, int length)
default long	findByte(byte stopByte)
boolean	isDirectMemory()
void	nativeRead(long position, long address, long size) expert level method for copying data to native memory.
default long	parseLong(long offset)
int	peekUnsignedByte(long offset) Read an unsigned byte at an offset, or -1
default int	peekVolatileInt()
default String	printable(long offset) Read the byte at an offset and converts it into a printable
default long	read(long offsetInRDI, byte[] bytes, int offset, int length)
default boolean	readBoolean(long offset) Read boolean at an offset
byte	readByte(long offset) Read byte at an offset
double	readDouble(long offset) Read a double at an offset
float	readFloat(long offset) Read a float at an offset
default long	readIncompleteLong(long offset) Read a long which is zero padded (high bytes) if the available bytes is less than 8.
int	readInt(long offset) Read an int at an offset
default long	readLimit()
long	readLong(long offset) Read a long at an offset
default long	readPosition() The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
default long	readRemaining()
short	readShort(long offset) Read a short at an offset
default int	readUnsignedByte(long offset) Read an unsigned byte at an offset
default long	readUnsignedInt(long offset) Read an unsigned int at an offset
default int	readUnsignedInt24(long offset) Read an unsigned int at an offset
default int	readUnsignedShort(long offset) Read an unsigned short at an offset
default <ACS extends Appendable & CharSequence> long	readUtf8(long offset, ACS sb) Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it.
default <ACS extends Appendable & CharSequence> long	readUtf8Limited(long offset, ACS sb, int maxUtf8Len) Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it.
default @Nullable String	readUtf8Limited(long offset, int maxUtf8Len) Reads a char sequence from the given offset, encoded as Utf8.
byte	readVolatileByte(long offset) Read a 8-bit byte from memory with a load barrier.
default double	readVolatileDouble(long offset) Read a 64-bit double from memory with a load barrier.
default float	readVolatileFloat(long offset) Read a float from memory with a load barrier.
int	readVolatileInt(long offset) Read a 32-bit int from memory with a load barrier.
long	readVolatileLong(long offset) Read a 64-bit long from memory with a load barrier.
short	readVolatileShort(long offset) Read a 16-bit short from memory with a load barrier.
long	realCapacity() Returns the actual capacity that can be potentially read.
boolean	sharedMemory()
default long	start()
default @NotNull BytesStore	subBytes(long start, long length) Copy a sub sequence of bytes as a BytesStore.
void	testAndSetInt(long offset, int expected, int value)
default @NotNull byte[]	toByteArray()
default ByteBuffer	toTemporaryDirectByteBuffer()
default long	writeLimit()
default long	writePosition() The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
default long	writeRemaining()

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCounted

refCount, release, releaseLast, releaseLast, reserve, reservedBy, reserveTransfer, tryReserve

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner

referenceId, referenceName, temporary

Field Detail

charToString

static final String[] charToString

Method Detail

createCharToString

@NotNull
static @NotNull String[] createCharToString()

peekVolatileInt

default int peekVolatileInt()
                     throws BufferUnderflowException

Throws:

BufferUnderflowException

readBoolean

default boolean readBoolean(long offset)
                     throws BufferUnderflowException

Read boolean at an offset

Parameters:

offset - to read

Returns:

the boolean

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readByte

byte readByte(long offset)
       throws BufferUnderflowException

Read byte at an offset

Parameters:

offset - to read

Returns:

the byte

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readUnsignedByte

default int readUnsignedByte(long offset)
                      throws BufferUnderflowException

Read an unsigned byte at an offset

Parameters:

offset - to read

Returns:

the unsigned byte

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

peekUnsignedByte

int peekUnsignedByte(long offset)
              throws BufferUnderflowException

Read an unsigned byte at an offset, or -1

Parameters:

offset - to read

Returns:

the unsigned byte or -1

Throws:

BufferUnderflowException

readShort

short readShort(long offset)
         throws BufferUnderflowException

Read a short at an offset

Parameters:

offset - to read

Returns:

the short

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readUnsignedShort

default int readUnsignedShort(long offset)
                       throws BufferUnderflowException

Read an unsigned short at an offset

Parameters:

offset - to read

Returns:

the unsigned short

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readUnsignedInt24

default int readUnsignedInt24(long offset)
                       throws BufferUnderflowException

Read an unsigned int at an offset

Parameters:

offset - to read

Returns:

the int

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readInt

int readInt(long offset)
     throws BufferUnderflowException

Read an int at an offset

Parameters:

offset - to read

Returns:

the int

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readUnsignedInt

default long readUnsignedInt(long offset)
                      throws BufferUnderflowException

Read an unsigned int at an offset

Parameters:

offset - to read

Returns:

the unsigned int

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readLong

long readLong(long offset)
       throws BufferUnderflowException

Read a long at an offset

Parameters:

offset - to read

Returns:

the long

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readFloat

float readFloat(long offset)
         throws BufferUnderflowException

Read a float at an offset

Parameters:

offset - to read

Returns:

the float

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readDouble

double readDouble(long offset)
           throws BufferUnderflowException

Read a double at an offset

Parameters:

offset - to read

Returns:

the double

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

printable

default String printable(long offset)
                  throws BufferUnderflowException

Read the byte at an offset and converts it into a printable

Parameters:

offset - to read

Returns:

the byte in a printable form.

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileByte

byte readVolatileByte(long offset)
               throws BufferUnderflowException

Read a 8-bit byte from memory with a load barrier.

Parameters:

offset - to read

Returns:

the byte value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileShort

short readVolatileShort(long offset)
                 throws BufferUnderflowException

Read a 16-bit short from memory with a load barrier.

Parameters:

offset - to read

Returns:

the short value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileInt

int readVolatileInt(long offset)
             throws BufferUnderflowException

Read a 32-bit int from memory with a load barrier.

Parameters:

offset - to read

Returns:

the int value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileFloat

default float readVolatileFloat(long offset)
                         throws BufferUnderflowException

Read a float from memory with a load barrier.

Parameters:

offset - to read

Returns:

the float value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileLong

long readVolatileLong(long offset)
               throws BufferUnderflowException

Read a 64-bit long from memory with a load barrier.

Parameters:

offset - to read

Returns:

the long value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

readVolatileDouble

default double readVolatileDouble(long offset)
                           throws BufferUnderflowException

Read a 64-bit double from memory with a load barrier.

Parameters:

offset - to read

Returns:

the double value

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

parseLong

default long parseLong(long offset)
                throws BufferUnderflowException

Throws:

BufferUnderflowException

nativeRead

void nativeRead(long position,
                long address,
                long size)
         throws BufferUnderflowException

expert level method for copying data to native memory.

Parameters:

position - within the ByteStore to copy.

address - in native memory

size - in bytes

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

copyTo

default int copyTo(@NotNull
                   @NotNull byte[] bytes)
            throws BufferUnderflowException

Read a byte[] from memory.

Returns:

the length actually read.

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

copyTo

default int copyTo(@NotNull
                   @NotNull ByteBuffer bb)
            throws BufferUnderflowException

Copy data from this RandomDataInput to the ByteBuffer. The minimum of readRemaining() and Buffer.remaining(). Starting from start() in this RandomDataInput and from Buffer.position() of the given bb. Does NOT change the position or limit or mark of the given ByteBuffer. Returns the number of the copied bytes.

Throws:

BufferUnderflowException

readIncompleteLong

default long readIncompleteLong(long offset)

Read a long which is zero padded (high bytes) if the available bytes is less than 8. If the offset is at or beyond the readLimit, this will return 0L.

Parameters:

offset - to read from

Returns:

the long which might be padded.

realCapacity

long realCapacity()

Returns the actual capacity that can be potentially read.

Returns:

the actual capacity that can be potentially read.

addAndGetInt

default int addAndGetInt(long offset,
                         int adding)
                  throws BufferUnderflowException

Perform an atomic add and get operation for a 32-bit int

Parameters:

offset - to add and get

adding - value to add, can be 1

Returns:

the sum

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

addAndGetLong

default long addAndGetLong(long offset,
                           long adding)
                    throws BufferUnderflowException

Perform an atomic add and get operation for a 64-bit long

Parameters:

offset - to add and get

adding - value to add, can be 1

Returns:

the sum

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

addAndGetFloat

default float addAndGetFloat(long offset,
                             float adding)
                      throws BufferUnderflowException

Perform an atomic add and get operation for a 32-bit float

Parameters:

offset - to add and get

adding - value to add, can be 1

Returns:

the sum

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

addAndGetDouble

default double addAndGetDouble(long offset,
                               double adding)
                        throws BufferUnderflowException

Perform an atomic add and get operation for a 64-bit double

Parameters:

offset - to add and get

adding - value to add, can be 1

Returns:

the sum

Throws:

BufferUnderflowException - if the offset is outside the limits of the Bytes

subBytes

@NotNull
default @NotNull BytesStore subBytes(long start,
                                              long length)
                                       throws BufferUnderflowException

Copy a sub sequence of bytes as a BytesStore.

Parameters:

start - of bytes

length - of bytes

Returns:

ByteStore copy.

Throws:

BufferUnderflowException

findByte

default long findByte(byte stopByte)

readUtf8

default <ACS extends Appendable & CharSequence> long readUtf8(long offset,
                                                              @NotNull
                                                              ACS sb)
                                                       throws net.openhft.chronicle.core.io.IORuntimeException,
                                                              IllegalArgumentException,
                                                              BufferUnderflowException

Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it. Returns offset after the read Utf8, if a normal char sequence was read, or -1 - offset, if null was observed (in this case, sb is truncated too, but not updated then, by querying sb only this case is indistinguishable from reading an empty char sequence).

Type Parameters:

ACS - buffer type, must be StringBuilder or Bytes

Parameters:

offset - the offset in this RandomDataInput to read char sequence from

sb - the buffer to read char sequence into (truncated first)

Returns:

offset after the normal read char sequence, or -1 - offset, if char sequence is null

Throws:

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

BufferUnderflowException

See Also:

RandomDataOutput.writeUtf8(long, CharSequence)

readUtf8Limited

default <ACS extends Appendable & CharSequence> long readUtf8Limited(long offset,
                                                                     @NotNull
                                                                     ACS sb,
                                                                     int maxUtf8Len)
                                                              throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                     IllegalArgumentException,
                                                                     BufferUnderflowException,
                                                                     IllegalStateException

Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it. Returns offset after the read Utf8, if a normal char sequence was read, or -1 - offset, if null was observed (in this case, sb is truncated too, but not updated then, by querying sb only this case is indistinguishable from reading an empty char sequence). If length of Utf8 encoding of the char sequence exceeds maxUtf8Len, IllegalStateException is thrown.

Type Parameters:

ACS - buffer type, must be StringBuilder or Bytes

Parameters:

offset - the offset in this RandomDataInput to read char sequence from

sb - the buffer to read char sequence into (truncated first)

maxUtf8Len - the maximum allowed length of the char sequence in Utf8 encoding

Returns:

offset after the normal read char sequence, or -1 - offset, if char sequence is null

Throws:

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

BufferUnderflowException

IllegalStateException

See Also:

RandomDataOutput.writeUtf8Limited(long, CharSequence, int)

readUtf8Limited

@Nullable
default @Nullable String readUtf8Limited(long offset,
                                                   int maxUtf8Len)
                                            throws BufferUnderflowException,
                                                   net.openhft.chronicle.core.io.IORuntimeException,
                                                   IllegalArgumentException,
                                                   IllegalStateException

Reads a char sequence from the given offset, encoded as Utf8. If length of Utf8 encoding of the char sequence exceeds maxUtf8Len, IllegalStateException is thrown.

Parameters:

offset - the offset in this RandomDataInput to read char sequence from

maxUtf8Len - the maximum allowed length of the char sequence in Utf8 encoding

Returns:

the char sequence was read

Throws:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

IllegalStateException

See Also:

RandomDataOutput.writeUtf8Limited(long, CharSequence, int)

compareUtf8

default boolean compareUtf8(long offset,
                            @Nullable
                            @Nullable CharSequence other)
                     throws net.openhft.chronicle.core.io.IORuntimeException

Compares the UTF-8 encoded char sequence, written in this RandomDataInput at the given offset, with the given char sequence. Returns true, if they are equal. Both char sequences (encoded in bytes and the given) may be null.

Parameters:

offset - the offset in this RandomDataInput where the char sequence to compare is written

other - the second char sequence to compare

Returns:

true if two char sequences are equal

Throws:

net.openhft.chronicle.core.io.IORuntimeException - if the contents are not a valid string.

toByteArray

@NotNull
default @NotNull byte[] toByteArray()
                                      throws IllegalArgumentException

Throws:

IllegalArgumentException

read

default long read(long offsetInRDI,
                  byte[] bytes,
                  int offset,
                  int length)

toTemporaryDirectByteBuffer

default ByteBuffer toTemporaryDirectByteBuffer()
                                        throws IllegalArgumentException

Throws:

IllegalArgumentException

fastHash

default int fastHash(long offset,
                     int length)
              throws BufferUnderflowException

Throws:

BufferUnderflowException

canReadDirect

default boolean canReadDirect(long length)

start

default long start()

Returns:

The smallest position allowed in this buffer.

capacity

default long capacity()

Returns:

the highest limit allowed for this buffer.

readPosition

default long readPosition()

The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()

Returns:

position to read from.

writePosition

default long writePosition()

The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()

Returns:

position to write to.

readRemaining

default long readRemaining()

Returns:

How many more bytes can we read.

writeRemaining

default long writeRemaining()

Returns:

How many more bytes can we written.

readLimit

default long readLimit()

Returns:

the highest offset or position allowed for this buffer.

writeLimit

default long writeLimit()

addressForRead

long addressForRead(long offset)
             throws UnsupportedOperationException,
                    BufferUnderflowException

Obtain the underlying addressForRead. This is for expert users only.

Parameters:

offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

BufferUnderflowException - if the offset is before the start() or the after the capacity()

addressForRead

default long addressForRead(long offset,
                            int buffer)
                     throws UnsupportedOperationException,
                            BufferUnderflowException

Throws:

UnsupportedOperationException

BufferUnderflowException

addressForWrite

long addressForWrite(long offset)
              throws UnsupportedOperationException,
                     BufferOverflowException

Obtain the underlying addressForRead. This is for expert users only.

Parameters:

offset - within this buffer. addressForRead(start()) is the actual addressForRead of the first byte.

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

BufferOverflowException - if the offset is before the start() or the after the capacity()

addressForWritePosition

long addressForWritePosition()
                      throws UnsupportedOperationException,
                             BufferOverflowException

Throws:

UnsupportedOperationException

BufferOverflowException

byteOrder

default ByteOrder byteOrder()

bytesForRead

@NotNull
@NotNull Bytes bytesForRead()
                              throws IllegalStateException

Returns:

the streaming bytes for reading.

Throws:

IllegalStateException

bytesForWrite

@NotNull
@NotNull Bytes bytesForWrite()
                               throws IllegalStateException

Returns:

the streaming bytes for writing.

Throws:

IllegalStateException

compareAndSwapInt

boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException

Perform a 32-bit CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

testAndSetInt

void testAndSetInt(long offset,
                   int expected,
                   int value)

compareAndSwapLong

boolean compareAndSwapLong(long offset,
                           long expected,
                           long value)
                    throws BufferOverflowException

Perform a 64-bit CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

compareAndSwapFloat

default boolean compareAndSwapFloat(long offset,
                                    float expected,
                                    float value)
                             throws BufferOverflowException

Perform a 32-bit float CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

compareAndSwapDouble

default boolean compareAndSwapDouble(long offset,
                                     double expected,
                                     double value)
                              throws BufferOverflowException

Perform a 64-bit double CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

sharedMemory

boolean sharedMemory()

Returns:

true if these Bytes use shared memory.

isDirectMemory

boolean isDirectMemory()