RandomDataInput (OpenHFT/Chronicle-Bytes 2.24ea16 API)

All Known Subinterfaces:

Bytes<U>, BytesIn<U>, BytesStore<B,U>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, ChunkedMappedBytes, CommonMappedBytes, EmbeddedBytes, GuardedNativeBytes, HeapBytesStore, HexDumpBytes, MappedBytes, MappedBytesStore, NativeBytes, NativeBytesStore, NoBytesStore, NoBytesStore, OnHeapBytes, PointerBytesStore, SingleMappedBytes, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface RandomDataInput
```
The RandomDataInput class provides a series of methods for reading data from various types of inputs. It allows to read data from an input source in a non-sequential manner, i.e., the data can be accessed at any offset.
This class supports reading of primitive data types like int, long, double etc., as well as more complex data structures like byte[], String and ByteBuffer. It also provides methods for direct reading from memory and for reading with a load barrier.
Furthermore, the RandomDataInput class provides additional methods for advanced operations like copying data to native memory, finding a specific byte, calculating the hash code of a sequence of bytes, and more.
Methods in this class may throw BufferUnderflowException if the offset specified is outside the limits of the byte sequence or IllegalStateException if the byte sequence has been released.
Note: Implementations of this class are typically not thread-safe. If multiple threads interact with a RandomDataInput instance concurrently, it must be synchronized externally.

Field Summary

Fields
Modifier and Type Field and Description

static String[] charToString
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT, TMP

Fields
Modifier and Type	Field and Description
`static String[]`	`charToString`

Method Summary

All Methods Static Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`default double`	`addAndGetDouble(long offset, double adding)` Deprecated.
`default float`	`addAndGetFloat(long offset, float adding)` Deprecated.
`default int`	`addAndGetInt(long offset, int adding)` Deprecated.
`default long`	`addAndGetLong(long offset, long adding)` Deprecated.
`long`	`addressForRead(long offset)` Retrieves the underlying memory address for reading.
`default long`	`addressForRead(long offset, int buffer)` Retrieves the underlying memory address for reading.
`long`	`addressForWrite(long offset)` Retrieves the underlying memory address for writing.
`long`	`addressForWritePosition()` Retrieves the underlying memory address for writing at the current write position.
`default ByteOrder`	`byteOrder()` Retrieves the byte order used by the buffer.
`@NotNull Bytes<?>`	`bytesForRead()` Retrieves a Bytes object for reading.
`@NotNull Bytes<?>`	`bytesForWrite()` Retrieves a Bytes object for writing.
`default boolean`	`canReadDirect()` Checks if this byte sequence can be read directly from native memory.
`default boolean`	`canReadDirect(long length)` Checks if the specified length of bytes can be read directly from native memory.
`default long`	`capacity()`
`default boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Deprecated.
`default boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Deprecated.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Deprecated.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Deprecated.
`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(byte[] bytes)` Copies data from this byte source into a byte array.
`default int`	`copyTo(@NotNull ByteBuffer bb)` Copies data from this RandomDataInput to the specified ByteBuffer.
`static @NotNull String[]`	`createCharToString()` Creates a lookup table mapping byte values to their corresponding String representations.
`default int`	`fastHash(long offset, int length)` Computes a hash code for a sequence of bytes.
`default long`	`findByte(byte stopByte)` Finds the first occurrence of the specified byte in this byte sequence.
`boolean`	`isDirectMemory()` Checks if the buffer uses direct memory.
`default long`	`lengthWritten(long startPosition)` Calculates the length of data written from the given start position.
`void`	`nativeRead(long position, long address, long size)` Expert-level method for transferring data from this byte source to native memory.
`default long`	`parseLong(long offset)` Parses a long value from a specified offset.
`int`	`peekUnsignedByte(long offset)` Reads an unsigned byte value from a specific offset.
`default int`	`peekVolatileInt()` Reads a volatile int value from the current reading position.
`default String`	`printable(long offset)` Reads a byte value from a specified offset and converts it into a printable string.
`default long`	`read(long offsetInRDI, byte[] bytes, int offset, int length)` Reads a sequence of bytes from the specified offset into a byte array.
`default boolean`	`readBoolean(long offset)` Reads a boolean value from a specific offset.
`byte`	`readByte(long offset)` Reads a byte value from a specific offset.
`double`	`readDouble(long offset)` Reads a 64-bit floating point value from a specified offset.
`float`	`readFloat(long offset)` Reads a 32-bit floating point value from a specified offset.
`default long`	`readIncompleteLong(long offset)` Reads a long value from the specified offset.
`int`	`readInt(long offset)` Reads a 32-bit integer value from a specific offset.
`default long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`long`	`readLong(long offset)` Reads a 64-bit long value from a specific offset.
`default long`	`readPosition()` Returns the read position.
`default long`	`readRemaining()` Calculates the number of bytes remaining that can be read from the current read position.
`short`	`readShort(long offset)` Reads a short value from a specific offset.
`default int`	`readUnsignedByte(long offset)` Reads an unsigned byte value from a specific offset.
`default long`	`readUnsignedInt(long offset)` Reads an unsigned 32-bit integer value from a specific offset.
`default int`	`readUnsignedInt24(long offset)` Reads an unsigned 24-bit integer value from a specific offset.
`default int`	`readUnsignedShort(long offset)` Reads an unsigned short value from a specific offset.
`default <T extends Appendable & CharSequence> long`	`readUtf8(long offset, T 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 @Nullable String`	`readUtf8Limited(long offset, int maxUtf8Len)` Reads a char sequence from the given `offset`, encoded as Utf8.
`default <T extends Appendable & CharSequence> long`	`readUtf8Limited(long offset, T 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.
`byte`	`readVolatileByte(long offset)` Reads a volatile 8-bit byte value from a specified offset.
`default double`	`readVolatileDouble(long offset)` Reads a volatile 64-bit double value from a specified offset.
`default float`	`readVolatileFloat(long offset)` Reads a volatile 32-bit floating point value from a specified offset.
`int`	`readVolatileInt(long offset)` Reads a volatile 32-bit integer value from a specified offset.
`long`	`readVolatileLong(long offset)` Reads a volatile 64-bit long value from a specified offset.
`short`	`readVolatileShort(long offset)` Reads a volatile 16-bit short value from a specified offset.
`long`	`realCapacity()` Returns the actual capacity that can be potentially read from this byte source.
`default long`	`realReadRemaining()` Calculates the number of bytes that can be safely read directly.
`default long`	`realWriteRemaining()` Calculates the number of bytes remaining that can be written from the current write position with resizing.
`boolean`	`sharedMemory()` Checks if the Bytes use shared memory.
`default long`	`start()`
`default @NotNull BytesStore`	`subBytes(long start, long length)` Returns a new BytesStore that is a subsequence of this byte sequence, starting at the specified index and of the specified length.
`void`	`testAndSetInt(long offset, int expected, int value)` Deprecated.
`default byte[]`	`toByteArray()`
`default ByteBuffer`	`toTemporaryDirectByteBuffer()` Converts the byte sequence into a direct byte buffer.
`default long`	`writeLimit()` Retrieves the maximum writable position within the buffer.
`default long`	`writePosition()` Returns the write position.
`default long`	`writeRemaining()` Calculates the number of bytes remaining that can be written from the current write position.

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCounted
addReferenceChangeListener, refCount, release, releaseLast, releaseLast, removeReferenceChangeListener, 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()
```
    Creates a lookup table mapping byte values to their corresponding String representations.
    
    Returns:
    
    a lookup table for byte-to-String conversions.
  - peekVolatileInt
```
default int peekVolatileInt()
                     throws BufferUnderflowException,
                            IllegalStateException
```
    Reads a volatile int value from the current reading position.
    
    Returns:
    
    the read int value.
    
    Throws:
    
    BufferUnderflowException - if the reading position is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readBoolean
```
default boolean readBoolean(long offset)
                     throws BufferUnderflowException,
                            IllegalStateException
```
    Reads a boolean value from a specific offset.
    
    Parameters:
    
    offset - the location from where the boolean value is read.
    
    Returns:
    
    the read boolean value.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readByte
```
byte readByte(long offset)
       throws BufferUnderflowException,
              IllegalStateException
```
    Reads a byte value from a specific offset.
    
    Parameters:
    
    offset - the location from where the byte value is read.
    
    Returns:
    
    the read byte value.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readUnsignedByte
```
default int readUnsignedByte(long offset)
                      throws BufferUnderflowException,
                             IllegalStateException
```
    Reads an unsigned byte value from a specific offset. The value is returned as an int in order to represent the unsigned byte as a positive value.
    
    Parameters:
    
    offset - the location from where the unsigned byte value is read.
    
    Returns:
    
    the unsigned byte value interpreted as a positive int.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - peekUnsignedByte
```
int peekUnsignedByte(long offset)
              throws IllegalStateException
```
    Reads an unsigned byte value from a specific offset. Returns -1 if the byte read is at the end of the byte source. The value is returned as an int in order to represent the unsigned byte as a positive value.
    
    Parameters:
    
    offset - the location from where the unsigned byte value is read.
    
    Returns:
    
    the unsigned byte value interpreted as a positive int or -1.
    
    Throws:
    
    IllegalStateException - if the byte source has been released.
  - readShort
```
short readShort(long offset)
         throws BufferUnderflowException,
                IllegalStateException
```
    Reads a short value from a specific offset.
    
    Parameters:
    
    offset - the location from where the short value is read.
    
    Returns:
    
    the read short value.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readUnsignedShort
```
default int readUnsignedShort(long offset)
                       throws BufferUnderflowException,
                              IllegalStateException
```
    Reads an unsigned short value from a specific offset. The value is returned as an int in order to represent the unsigned short as a positive value.
    
    Parameters:
    
    offset - the location from where the unsigned short value is read.
    
    Returns:
    
    the unsigned short value interpreted as a positive int.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readUnsignedInt24
```
default int readUnsignedInt24(long offset)
                       throws BufferUnderflowException,
                              IllegalStateException
```
    Reads an unsigned 24-bit integer value from a specific offset. The value is returned as an int, with the upper 8 bits zeroed.
    
    Parameters:
    
    offset - the location from where the unsigned 24-bit integer value is read.
    
    Returns:
    
    the unsigned 24-bit integer value interpreted as a positive int.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readInt
```
int readInt(long offset)
     throws BufferUnderflowException,
            IllegalStateException
```
    Reads a 32-bit integer value from a specific offset.
    
    Parameters:
    
    offset - the location from where the 32-bit integer value is read.
    
    Returns:
    
    the read int value.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readUnsignedInt
```
default long readUnsignedInt(long offset)
                      throws BufferUnderflowException,
                             IllegalStateException
```
    Reads an unsigned 32-bit integer value from a specific offset. The value is returned as a long in order to represent the unsigned int as a positive value.
    
    Parameters:
    
    offset - the location from where the unsigned 32-bit integer value is read.
    
    Returns:
    
    the unsigned 32-bit integer value interpreted as a positive long.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readLong
```
long readLong(long offset)
       throws BufferUnderflowException,
              IllegalStateException
```
    Reads a 64-bit long value from a specific offset.
    
    Parameters:
    
    offset - the location from where the long value is read.
    
    Returns:
    
    the read long value.
    
    Throws:
    
    BufferUnderflowException - if the offset is outside the bounds of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readFloat
```
float readFloat(long offset)
         throws BufferUnderflowException,
                IllegalStateException
```
    Reads a 32-bit floating point value from a specified offset.
    
    Parameters:
    
    offset - the location from where the float value is read.
    
    Returns:
    
    the read float value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readDouble
```
double readDouble(long offset)
           throws BufferUnderflowException,
                  IllegalStateException
```
    Reads a 64-bit floating point value from a specified offset.
    
    Parameters:
    
    offset - the location from where the double value is read.
    
    Returns:
    
    the read double value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - printable
```
default String printable(long offset)
                  throws BufferUnderflowException,
                         IllegalStateException
```
    Reads a byte value from a specified offset and converts it into a printable string.
    
    Parameters:
    
    offset - the location from where the byte value is read.
    
    Returns:
    
    the byte value in a printable string form.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readVolatileByte
```
byte readVolatileByte(long offset)
               throws BufferUnderflowException,
                      IllegalStateException
```
    Reads a volatile 8-bit byte value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
    
    Parameters:
    
    offset - the location from where the byte value is read.
    
    Returns:
    
    the volatile byte value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readVolatileShort
```
short readVolatileShort(long offset)
                 throws BufferUnderflowException,
                        IllegalStateException
```
    Reads a volatile 16-bit short value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
    
    Parameters:
    
    offset - the location from where the short value is read.
    
    Returns:
    
    the volatile short value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readVolatileInt
```
int readVolatileInt(long offset)
             throws BufferUnderflowException,
                    IllegalStateException
```
    Reads a volatile 32-bit integer value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
    
    Parameters:
    
    offset - the location from where the int value is read.
    
    Returns:
    
    the volatile int value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readVolatileFloat
```
default float readVolatileFloat(long offset)
                         throws BufferUnderflowException,
                                IllegalStateException
```
    Reads a volatile 32-bit floating point value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
    
    Parameters:
    
    offset - the location from where the float value is read.
    
    Returns:
    
    the volatile float value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readVolatileLong
```
long readVolatileLong(long offset)
               throws BufferUnderflowException,
                      IllegalStateException
```
    Reads a volatile 64-bit long value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
    
    Parameters:
    
    offset - the location from where the long value is read.
    
    Returns:
    
    the volatile long value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readVolatileDouble
```
default double readVolatileDouble(long offset)
                           throws BufferUnderflowException,
                                  IllegalStateException
```
    Reads a volatile 64-bit double value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
    
    Parameters:
    
    offset - the location from where the double value is read.
    
    Returns:
    
    the volatile double value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - parseLong
```
default long parseLong(long offset)
                throws BufferUnderflowException,
                       IllegalStateException
```
    Parses a long value from a specified offset.
    
    Parameters:
    
    offset - the location from where the long value is read.
    
    Returns:
    
    the parsed long value.
    
    Throws:
    
    BufferUnderflowException - if the offset is beyond the limits of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - nativeRead
```
void nativeRead(long position,
                long address,
                long size)
         throws BufferUnderflowException,
                IllegalStateException
```
    Expert-level method for transferring data from this byte source to native memory.
    
    Parameters:
    
    position - the starting point within the byte source from which data is copied.
    
    address - the destination address in native memory.
    
    size - the number of bytes to transfer.
    
    Throws:
    
    BufferUnderflowException - if the specified position or size exceeds the byte source limits.
    
    IllegalStateException - if the byte source has been released.
  - copyTo
```
default int copyTo(byte[] bytes)
            throws BufferUnderflowException,
                   IllegalStateException
```
    Copies data from this byte source into a byte array. The data is read from RandomCommon.readPosition() up to RandomCommon.readLimit().
    
    Parameters:
    
    bytes - the target byte array to which the data is copied.
    
    Returns:
    
    the number of bytes actually copied.
    
    Throws:
    
    BufferUnderflowException - if the source's read position or limit is beyond the byte source limits.
    
    IllegalStateException - if the byte source has been released.
  - copyTo
```
default int copyTo(@NotNull
                   @NotNull ByteBuffer bb)
            throws BufferUnderflowException,
                   IllegalStateException
```
    Copies data from this RandomDataInput to the specified ByteBuffer. The number of copied bytes is the minimum of the remaining bytes to read in this RandomDataInput and the remaining capacity of the ByteBuffer. The data copying starts from the current read position in this RandomDataInput and from the current position in the ByteBuffer. The ByteBuffer's position, limit, or mark are not modified by this operation. Returns the number of bytes copied.
    
    Parameters:
    
    bb - the target ByteBuffer to which the data is copied.
    
    Returns:
    
    the number of bytes copied.
    
    Throws:
    
    BufferUnderflowException - if the read operation encounters end of the byte source.
    
    IllegalStateException - if the byte source has been released.
  - readIncompleteLong
```
default long readIncompleteLong(long offset)
                         throws IllegalStateException
```
    Reads a long value from the specified offset. If less than 8 bytes are available to read, this method pads the high bytes with zeros. If the offset is at or beyond the read limit, this method returns 0L.
    
    Parameters:
    
    offset - the location from where the long value is read.
    
    Returns:
    
    the long value, potentially zero-padded.
    
    Throws:
    
    IllegalStateException - if the byte source has been released.
  - realCapacity
```
long realCapacity()
```
    Returns the actual capacity that can be potentially read from this byte source.
    
    Returns:
    
    the actual readable capacity.
  - addAndGetInt
```
@Deprecated
default int addAndGetInt(long offset,
                                     int adding)
                              throws BufferUnderflowException,
                                     IllegalStateException
```
    Deprecated.
    
    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
    
    IllegalStateException - if released
  - addAndGetLong
```
@Deprecated
default long addAndGetLong(long offset,
                                       long adding)
                                throws BufferUnderflowException,
                                       IllegalStateException
```
    Deprecated.
    
    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
    
    IllegalStateException - if released
  - addAndGetFloat
```
@Deprecated
default float addAndGetFloat(long offset,
                                         float adding)
                                  throws BufferUnderflowException,
                                         IllegalStateException
```
    Deprecated.
    
    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
    
    IllegalStateException - if released
  - addAndGetDouble
```
@Deprecated
default double addAndGetDouble(long offset,
                                           double adding)
                                    throws BufferUnderflowException,
                                           IllegalStateException
```
    Deprecated.
    
    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
    
    IllegalStateException - if released
  - compareAndSwapInt
```
@Deprecated
boolean compareAndSwapInt(long offset,
                                      int expected,
                                      int value)
                               throws BufferOverflowException,
                                      IllegalStateException
```
    Deprecated.
    
    Perform a 32-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    IllegalStateException - if released
    
    BufferOverflowException
  - testAndSetInt
```
@Deprecated
void testAndSetInt(long offset,
                               int expected,
                               int value)
                        throws BufferOverflowException,
                               IllegalStateException
```
    Deprecated.
    
    Throws:
    
    BufferOverflowException
    
    IllegalStateException
  - compareAndSwapLong
```
@Deprecated
boolean compareAndSwapLong(long offset,
                                       long expected,
                                       long value)
                                throws BufferOverflowException,
                                       IllegalStateException
```
    Deprecated.
    
    Perform a 64-bit CAS at a given offset.
    
    Parameters:
    
    offset - to perform CAS
    
    expected - value
    
    value - to set
    
    Returns:
    
    true, if successful.
    
    Throws:
    
    IllegalStateException - if released
    
    BufferOverflowException
  - compareAndSwapFloat
```
@Deprecated
default boolean compareAndSwapFloat(long offset,
                                                float expected,
                                                float value)
                                         throws BufferOverflowException,
                                                IllegalStateException
```
    Deprecated.
    
    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:
    
    IllegalStateException - if released
    
    BufferOverflowException
  - compareAndSwapDouble
```
@Deprecated
default boolean compareAndSwapDouble(long offset,
                                                 double expected,
                                                 double value)
                                          throws BufferOverflowException,
                                                 IllegalStateException
```
    Deprecated.
    
    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:
    
    IllegalStateException - if released
    
    BufferOverflowException
  - subBytes
```
@NotNull
default @NotNull BytesStore subBytes(long start,
                                              long length)
                                       throws BufferUnderflowException,
                                              IllegalStateException
```
    Returns a new BytesStore that is a subsequence of this byte sequence, starting at the specified index and of the specified length.
    
    Parameters:
    
    start - the start index, inclusive.
    
    length - the length of the subsequence.
    
    Returns:
    
    a new BytesStore instance containing the specified subsequence.
    
    Throws:
    
    BufferUnderflowException - if the start index or length are outside the limits of this byte sequence.
    
    IllegalStateException - if the byte source has been released.
  - findByte
```
default long findByte(byte stopByte)
               throws IllegalStateException
```
    Finds the first occurrence of the specified byte in this byte sequence.
    
    Parameters:
    
    stopByte - the byte to be searched for.
    
    Returns:
    
    the index of the first occurrence of the byte, or -1 if the byte is not found.
    
    Throws:
    
    IllegalStateException - if the byte source has been released.
  - readUtf8
```
default <T extends Appendable & CharSequence> long readUtf8(long offset,
                                                            @NotNull
                                                            T sb)
                                                     throws net.openhft.chronicle.core.io.IORuntimeException,
                                                            IllegalArgumentException,
                                                            BufferUnderflowException,
                                                            ArithmeticException,
                                                            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).
    
    Type Parameters:
    
    T - 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 - if the reading operation encounters an unexpected error.
    
    IllegalArgumentException - if the buffer is not a StringBuilder or Bytes.
    
    BufferUnderflowException - if the reading operation encounters the end of the byte source.
    
    ArithmeticException - if the calculated length of the UTF-8 encoded string is invalid.
    
    IllegalStateException - if the byte source has been released.
    
    See Also:
    
    RandomDataOutput.writeUtf8(long, CharSequence)
  - readUtf8Limited
```
default <T extends Appendable & CharSequence> long readUtf8Limited(long offset,
                                                                   @NotNull
                                                                   T 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:
    
    T - 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:
    
    IllegalStateException - if released
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    BufferUnderflowException
    
    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:
    
    IllegalStateException - if released
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    See Also:
    
    RandomDataOutput.writeUtf8Limited(long, CharSequence, int)
  - compareUtf8
```
default boolean compareUtf8(long offset,
                            @Nullable
                            @Nullable CharSequence other)
                     throws net.openhft.chronicle.core.io.IORuntimeException,
                            BufferUnderflowException,
                            IllegalStateException
```
    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:
    
    IllegalStateException - if released
    
    net.openhft.chronicle.core.io.IORuntimeException - if the contents are not a valid string.
    
    BufferUnderflowException
  - toByteArray
```
default byte[] toByteArray()
                    throws IllegalStateException
```
    Throws:
    
    IllegalStateException
  - read
```
default long read(long offsetInRDI,
                  byte[] bytes,
                  int offset,
                  int length)
           throws IllegalStateException
```
    Reads a sequence of bytes from the specified offset into a byte array.
    
    Parameters:
    
    offsetInRDI - the offset in the byte sequence from which to start reading.
    
    bytes - the byte array into which the data is read.
    
    offset - the start offset in the byte array at which the data is written.
    
    length - the maximum number of bytes to read.
    
    Returns:
    
    the actual number of bytes read into the byte array.
    
    Throws:
    
    IllegalStateException - if the byte sequence has been released.
  - toTemporaryDirectByteBuffer
```
default ByteBuffer toTemporaryDirectByteBuffer()
                                        throws IllegalArgumentException,
                                               ArithmeticException,
                                               IllegalStateException
```
    Converts the byte sequence into a direct byte buffer.
    
    Returns:
    
    a direct ByteBuffer containing the data of this byte sequence.
    
    Throws:
    
    IllegalArgumentException - if the byte sequence cannot be converted into a ByteBuffer.
    
    ArithmeticException - if the calculated size of the ByteBuffer is invalid.
    
    IllegalStateException - if the byte sequence has been released.
  - fastHash
```
default int fastHash(long offset,
                     int length)
              throws BufferUnderflowException,
                     IllegalStateException
```
    Computes a hash code for a sequence of bytes.
    
    Parameters:
    
    offset - the start offset of the sequence of bytes.
    
    length - the length of the sequence of bytes.
    
    Returns:
    
    a hash code value for the specified sequence of bytes.
    
    Throws:
    
    BufferUnderflowException - if the specified sequence of bytes extends beyond the limits of this byte sequence.
    
    IllegalStateException - if the byte sequence has been released.
  - canReadDirect
```
default boolean canReadDirect()
```
    Checks if this byte sequence can be read directly from native memory.
    
    Returns:
    
    true if the byte sequence can be read directly, false otherwise.
  - canReadDirect
```
default boolean canReadDirect(long length)
```
    Checks if the specified length of bytes can be read directly from native memory.
    
    Parameters:
    
    length - the number of bytes to check.
    
    Returns:
    
    true if the byte sequence is backed by direct memory and the remaining bytes are more than or equal to the specified length, false otherwise.
  - 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()
```
    Returns the read position.
    The read position is start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    position to read from.
  - writePosition
```
default long writePosition()
```
    Returns the write position.
    The write position is readPosition() <= writePosition() && writePosition() <= writeLimit()
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    position to write to.
  - lengthWritten
```
default long lengthWritten(long startPosition)
```
    Calculates the length of data written from the given start position.
    Typically this calculates the difference however for HexDumpBytes it's not as simple.
    If the resource is closed, the returned value is unspecified.
    
    Parameters:
    
    startPosition - The position to calculate the length from.
    
    Returns:
    
    The length of data written from the given start position.
  - readRemaining
```
default long readRemaining()
```
    Calculates the number of bytes remaining that can be read from the current read position.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can still be read.
  - realReadRemaining
```
default long realReadRemaining()
```
    Calculates the number of bytes that can be safely read directly.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can be safely read directly.
  - writeRemaining
```
default long writeRemaining()
```
    Calculates the number of bytes remaining that can be written from the current write position.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can still be written.
  - realWriteRemaining
```
default long realWriteRemaining()
```
    Calculates the number of bytes remaining that can be written from the current write position with resizing.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can still be written with resizing.
  - readLimit
```
default long readLimit()
```
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    the highest offset or position allowed for this buffer.
  - writeLimit
```
default long writeLimit()
```
    Retrieves the maximum writable position within the buffer.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    the write limit
  - addressForRead
```
long addressForRead(long offset)
             throws UnsupportedOperationException,
                    BufferUnderflowException,
                    IllegalStateException
```
    Retrieves the underlying memory address for reading. 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()
    
    IllegalStateException - if the buffer has been closed.
  - addressForRead
```
default long addressForRead(long offset,
                            int buffer)
                     throws UnsupportedOperationException,
                            BufferUnderflowException,
                            IllegalStateException
```
    Retrieves the underlying memory address for reading. This is for expert users only.
    
    Parameters:
    
    offset - The offset within this buffer.
    
    buffer - The buffer index.
    
    Returns:
    
    The underlying memory address for reading at the specified offset.
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap.
    
    BufferUnderflowException - if the offset is before the start or after the capacity.
    
    IllegalStateException - if the buffer has been closed.
  - addressForWrite
```
long addressForWrite(long offset)
              throws UnsupportedOperationException,
                     BufferOverflowException,
                     IllegalStateException
```
    Retrieves the underlying memory address for writing. 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()
    
    IllegalStateException
  - addressForWritePosition
```
long addressForWritePosition()
                      throws UnsupportedOperationException,
                             BufferOverflowException,
                             IllegalStateException
```
    Retrieves the underlying memory address for writing at the current write position. This is for expert users only.
    
    Returns:
    
    The underlying memory address for writing at the current write position.
    
    Throws:
    
    UnsupportedOperationException - if the underlying buffer is on the heap.
    
    BufferOverflowException - if the current write position is before the start or after the capacity.
    
    IllegalStateException - if the buffer state doesn't allow the operation.
  - byteOrder
```
default ByteOrder byteOrder()
```
    Retrieves the byte order used by the buffer.
    
    Returns:
    
    The byte order used by the buffer.
  - bytesForRead
```
@NotNull
@NotNull Bytes<?> bytesForRead()
                                 throws IllegalStateException
```
    Retrieves a Bytes object for reading.
    
    Returns:
    
    A Bytes object for reading.
    
    Throws:
    
    IllegalStateException - if the buffer state doesn't allow the operation.
  - bytesForWrite
```
@NotNull
@NotNull Bytes<?> bytesForWrite()
                                  throws IllegalStateException
```
    Retrieves a Bytes object for writing.
    
    Returns:
    
    A Bytes object for writing.
    
    Throws:
    
    IllegalStateException - if the buffer state doesn't allow the operation.
  - sharedMemory
```
boolean sharedMemory()
```
    Checks if the Bytes use shared memory.
    
    Returns:
    
    True if the Bytes use shared memory, false otherwise.
  - isDirectMemory
```
boolean isDirectMemory()
```
    Checks if the buffer uses direct memory.
    
    Returns:
    
    True if the buffer uses direct memory, false otherwise.

Interface RandomDataInput

Field Summary

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

Method Summary

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

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

Field Detail

charToString

Method Detail

createCharToString

peekVolatileInt

readBoolean

readByte

readUnsignedByte

peekUnsignedByte

readShort

readUnsignedShort

readUnsignedInt24

readInt

readUnsignedInt

readLong

readFloat

readDouble

printable

readVolatileByte

readVolatileShort

readVolatileInt

readVolatileFloat

readVolatileLong

readVolatileDouble

parseLong

nativeRead

copyTo

copyTo

readIncompleteLong

realCapacity

addAndGetInt

addAndGetLong

addAndGetFloat

addAndGetDouble

compareAndSwapInt

testAndSetInt

compareAndSwapLong

compareAndSwapFloat

compareAndSwapDouble

subBytes

findByte

readUtf8

readUtf8Limited

readUtf8Limited

compareUtf8

toByteArray

read

toTemporaryDirectByteBuffer

fastHash

canReadDirect

canReadDirect

start

capacity

readPosition

writePosition

lengthWritten

readRemaining

realReadRemaining

writeRemaining

realWriteRemaining

readLimit

writeLimit

addressForRead

addressForRead

addressForWrite

addressForWritePosition

byteOrder

bytesForRead

bytesForWrite

sharedMemory

isDirectMemory