StreamingDataInput (OpenHFT/Chronicle-Bytes 2.24ea16 API)

Type Parameters:

S - the type of StreamingDataInput

All Superinterfaces:

StreamingCommon<S>

All Known Subinterfaces:

Bytes<U>, BytesIn<U>, ByteStringParser<B>

All Known Implementing Classes:

AbstractBytes, ChunkedMappedBytes, CommonMappedBytes, EmbeddedBytes, GuardedNativeBytes, HexDumpBytes, MappedBytes, NativeBytes, OnHeapBytes, SingleMappedBytes, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface StreamingDataInput<S extends StreamingDataInput<S>>
extends StreamingCommon<S>
```
The StreamingDataInput interface represents a data stream for reading in binary data. It provides a range of read methods to retrieve different types of data from the stream, such as integers, longs, floating-point numbers, strings, byte arrays, etc.
Reading methods in this interface are usually expected to advance the read position by the number of bytes read. This allows consecutive calls to the read methods to sequentially read chunks of data from the stream.
Additionally, StreamingDataInput provides support for leniency and conversion of data into BigInteger or BigDecimal objects. When lenient mode is enabled, methods will return default values when there's no more data to read, instead of throwing exceptions.
The interface includes methods for handling exceptions and managing the state of the stream, such as checking the remaining bytes or throwing an exception if the stream has been previously released.
Defines a data input interface that supports setting and getting positions and limits. Implementing classes can be used to read data from a data source, typically a byte stream or byte buffer.
Note: Implementations of this interface may choose to handle the actual reading of data in various ways, such as through direct memory access or other optimized mechanisms.

Field Summary
- Fields inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT, TMP

Method Summary

All Methods Instance Methods Abstract Methods Default Methods
Modifier and Type	Method and Description
`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 long`	`capacity()`
`long`	`copyTo(@NotNull BytesStore to)` Copies the data from the input stream to the provided BytesStore.
`void`	`copyTo(@NotNull OutputStream out)` Copies the data from the input stream to the provided OutputStream.
`default @NotNull InputStream`	`inputStream()` Provides an InputStream for the data represented by this StreamingDataInput.
`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.
`boolean`	`lenient()`
`void`	`lenient(boolean lenient)` When there is no more data to read, return zero, `false` and empty string.
`default long`	`parseHexLong()` Parses a hexadecimal long value from the input stream.
`default void`	`parseUtf8(@NotNull Appendable sb, boolean utf, int length)` Parses a UTF-8 string from the input stream into the provided Appendable.
`default void`	`parseUtf8(@NotNull Appendable sb, int encodedLength)` Parses a UTF-8 string from the input stream into the provided Appendable.
`int`	`peekUnsignedByte()` Peeks (reads without moving the read pointer) the next unsigned byte from the input stream.
`default byte`	`rawReadByte()` Reads a raw byte value from the input stream.
`default int`	`rawReadInt()` Reads a 32-bit integer value from the input stream without performing boundary checks.
`default long`	`rawReadLong()` Reads a 64-bit long value from the input stream without performing boundary checks.
`default int`	`read(byte[] bytes)` Reads the input stream into the provided byte array.
`default int`	`read(byte[] bytes, int off, int len)` Reads the input stream into the provided byte array, starting from the given offset and reading up to the specified length.
`default void`	`read(@NotNull ByteBuffer buffer)` Reads the input stream into the provided ByteBuffer.
`default void`	`read(@NotNull Bytes<?> bytes)` Transfers as many bytes as possible from the input stream into the provided Bytes object.
`default void`	`read(@NotNull Bytes<?> bytes, int length)` Transfers the specified number of bytes from the input stream into the provided Bytes object.
`default int`	`read(char[] bytes, int off, int len)` Reads the input stream into the provided char array, starting from the given offset and reading up to the specified length.
`default @Nullable String`	`read8bit()` Reads an 8-bit encoded string from the input stream.
`default boolean`	`read8bit(@NotNull Bytes<?> b)` Reads an 8-bit encoded string from the input stream and appends it to the provided Bytes.
`default boolean`	`read8bit(@NotNull StringBuilder sb)` Reads an 8-bit encoded string from the input stream and appends it to the provided StringBuilder.
`default @NotNull BigDecimal`	`readBigDecimal()` Creates and returns a new BigDecimal representing the contents of this Bytes object.
`default @NotNull BigInteger`	`readBigInteger()` Creates and returns a new BigInteger representing the contents of this Bytes object or `BigInteger.ZERO` if this Bytes object is empty.
`default boolean`	`readBoolean()` Reads a boolean value from the input stream.
`byte`	`readByte()` Reads a byte value from the input stream.
`default char`	`readChar()` Reads a character value from the input stream.
`double`	`readDouble()` Reads a 64-bit floating-point number from the input stream.
`default <E extends Enum<E>> E`	`readEnum(@NotNull Class<E> eClass)` Reads an Enum value from the input stream.
`float`	`readFloat()` Reads a 32-bit floating-point number from the input stream.
`default void`	`readHistogram(@NotNull net.openhft.chronicle.core.util.Histogram histogram)` Reads data from the input stream into the provided Histogram.
`default long`	`readIncompleteLong()`
`int`	`readInt()` Reads a 32-bit integer value from the input stream.
`default int`	`readInt24()` Reads a 24-bit signed integer value from the input stream.
`default long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`S`	`readLimit(long limit)` Sets the read limit of this StreamingDataInput.
`default S`	`readLimitToCapacity()` Sets the read limit of this StreamingDataInput to its capacity.
`long`	`readLong()` Reads a 64-bit long value from the input stream.
`default long`	`readPosition()` Returns the read position.
`S`	`readPosition(long position)` Sets the read position of this StreamingDataInput.
`default long`	`readPositionForHeader(boolean skipPadding)` Obtains the current read position, optionally skipping padding bytes if specified.
`default S`	`readPositionRemaining(long position, long remaining)` Sets the read position and limit of this StreamingDataInput based on the specified position and remaining values.
`default S`	`readPositionUnlimited(long position)` Sets the read position of this StreamingDataInput without limiting it to the current read limit.
`default long`	`readRemaining()` Calculates the number of bytes remaining that can be read from the current read position.
`short`	`readShort()` Reads a 16-bit short value from the input stream.
`S`	`readSkip(long bytesToSkip)` Skips the specified number of bytes by advancing the read position.
`default long`	`readStopBit()` Reads a variable-length integer encoded using the stop bit encoding.
`default char`	`readStopBitChar()` Reads a variable-length character encoded using the stop bit encoding.
`default double`	`readStopBitDecimal()` Reads a decimal number represented as a variable-length double and scale encoded using the stop bit encoding.
`default double`	`readStopBitDouble()` Reads a variable-length double encoded using the stop bit encoding.
`int`	`readUnsignedByte()` Reads the next unsigned 8-bit value from the input stream.
`default long`	`readUnsignedInt()` Reads a 32-bit value from the input stream and converts it to an unsigned integer by masking the sign bit.
`default int`	`readUnsignedInt24()` Reads a 24-bit unsigned integer value from the input stream.
`default int`	`readUnsignedShort()` Reads a 16-bit value from the input stream and converts it to an unsigned short by masking the sign bit.
`default @Nullable String`	`readUtf8()` Reads a UTF-8 encoded string from the input stream.
`default boolean`	`readUtf8(@NotNull Bytes<?> sb)` Reads a UTF-8 encoded string from the input stream and appends it to the provided Bytes.
`default <C extends Appendable & CharSequence> boolean`	`readUtf8(C sb)` Reads a UTF-8 encoded string from the input stream and appends it to the provided appendable.
`default boolean`	`readUtf8(@NotNull StringBuilder sb)` Reads a UTF-8 encoded string from the input stream and appends it to the provided StringBuilder.
`int`	`readVolatileInt()` Reads a volatile (concurrently mutable) integer value from the input stream.
`long`	`readVolatileLong()` Reads a volatile (concurrently mutable) long value from the input stream.
`default void`	`readWithLength(@NotNull Bytes<?> bytes)` Reads data from the input stream with specified length into the provided Bytes.
`default void`	`readWithLength(long length, @NotNull net.openhft.chronicle.core.util.ThrowingConsumer<S,net.openhft.chronicle.core.io.IORuntimeException> bytesConsumer)` Perform a set of actions within a temporary bounds mode.
`default void`	`readWithLength0(long length, @NotNull net.openhft.chronicle.core.util.ThrowingConsumerNonCapturing<S,net.openhft.chronicle.core.io.IORuntimeException,BytesOut> bytesConsumer, StringBuilder sb, BytesOut<?> toBytes)` Perform a set of actions within a temporary bounds mode.
`default long`	`realCapacity()`
`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()`
`void`	`uncheckedReadSkipBackOne()` Unchecked version of readSkip(-1).
`void`	`uncheckedReadSkipOne()` Unchecked version of readSkip(1).
`int`	`uncheckedReadUnsignedByte()` Reads the next unsigned 8-bit value from the input stream without performing boundary checks.
`default S`	`unsafeRead(long address, int length)` Reads data from the input stream into the memory at the provided address.
`default void`	`unsafeReadObject(@NotNull Object o, int length)` Reads data from the input stream into the provided object.
`default void`	`unsafeReadObject(@NotNull Object o, int offset, int length)` Reads data from the input stream into the provided object, starting from the given offset.
`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.bytes.StreamingCommon
clear

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

- Method Detail
  - readPosition
```
@NotNull
S readPosition(long position)
                 throws BufferUnderflowException,
                        IllegalStateException
```
    Sets the read position of this StreamingDataInput.
    
    Parameters:
    
    position - the new read position, must be non-negative
    
    Returns:
    
    this StreamingDataInput instance, for chaining
    
    Throws:
    
    BufferUnderflowException - if the new position is greater than the limit
    
    IllegalStateException - if a required state for this operation is not met
  - readPositionUnlimited
```
@NotNull
default S readPositionUnlimited(long position)
                                  throws BufferUnderflowException,
                                         IllegalStateException
```
    Sets the read position of this StreamingDataInput without limiting it to the current read limit.
    
    Parameters:
    
    position - the new read position, must be non-negative
    
    Returns:
    
    this StreamingDataInput instance, for chaining
    
    Throws:
    
    BufferUnderflowException - if the new position is greater than the capacity
    
    IllegalStateException - if a required state for this operation is not met
  - readPositionRemaining
```
@NotNull
default S readPositionRemaining(long position,
                                         long remaining)
                                  throws BufferUnderflowException,
                                         IllegalStateException
```
    Sets the read position and limit of this StreamingDataInput based on the specified position and remaining values.
    
    Parameters:
    
    position - the new read position, must be non-negative
    
    remaining - the remaining size, which is used to set the read limit
    
    Returns:
    
    this StreamingDataInput instance, for chaining
    
    Throws:
    
    BufferUnderflowException - if the new position is greater than the read limit
    
    IllegalStateException - if a required state for this operation is not met
  - readLimit
```
@NotNull
S readLimit(long limit)
              throws BufferUnderflowException
```
    Sets the read limit of this StreamingDataInput.
    
    Parameters:
    
    limit - the new read limit, must be non-negative
    
    Returns:
    
    this StreamingDataInput instance, for chaining
    
    Throws:
    
    BufferUnderflowException - if the new limit is less than the read position
  - readLimitToCapacity
```
default S readLimitToCapacity()
                       throws BufferUnderflowException
```
    Sets the read limit of this StreamingDataInput to its capacity.
    
    Returns:
    
    this StreamingDataInput instance, for chaining
    
    Throws:
    
    BufferUnderflowException - if the capacity is less than the read position
  - readSkip
```
@NotNull
S readSkip(long bytesToSkip)
             throws BufferUnderflowException,
                    IllegalStateException
```
    Skips the specified number of bytes by advancing the read position. The number of bytes to skip must be less than or equal to the read limit.
    
    Parameters:
    
    bytesToSkip - the number of bytes to skip
    
    Returns:
    
    this StreamingDataInput instance, for chaining
    
    Throws:
    
    BufferUnderflowException - if the new read position is outside the limits of the data source
    
    IllegalStateException - if a required state for this operation is not met
  - readPositionForHeader
```
default long readPositionForHeader(boolean skipPadding)
```
    Obtains the current read position, optionally skipping padding bytes if specified. Useful when reading data with headers that may include padding.
    
    Parameters:
    
    skipPadding - if true, aligns the read position to a 4-byte boundary by skipping padding bytes
    
    Returns:
    
    the current read position
  - uncheckedReadSkipOne
```
void uncheckedReadSkipOne()
```
    Unchecked version of readSkip(1). This method skips one byte without performing any limit checks. Use this method only when you are certain that it is safe to do so, and you have identified a performance issue with readSkip(1).
  - uncheckedReadSkipBackOne
```
void uncheckedReadSkipBackOne()
```
    Unchecked version of readSkip(-1). This method skips back one byte without performing any limit checks. Use this method only when you are certain that it is safe to do so, and you have identified a performance issue with readSkip(-1).
  - readWithLength0
```
default void readWithLength0(long length,
                             @NotNull
                             @NotNull net.openhft.chronicle.core.util.ThrowingConsumerNonCapturing<S,net.openhft.chronicle.core.io.IORuntimeException,BytesOut> bytesConsumer,
                             StringBuilder sb,
                             BytesOut<?> toBytes)
                      throws BufferUnderflowException,
                             net.openhft.chronicle.core.io.IORuntimeException,
                             IllegalStateException
```
    Perform a set of actions within a temporary bounds mode. The bounds are defined by the specified length. After the consumer has been executed, the original read limit is restored and the read position is moved forward by the specified length.
    
    Parameters:
    
    length - the length to set the temporary bounds to
    
    bytesConsumer - the consumer to execute within the temporary bounds
    
    sb - the StringBuilder to use
    
    toBytes - the BytesOut to use
    
    Throws:
    
    BufferUnderflowException - if the specified length is greater than the number of bytes remaining to read
    
    net.openhft.chronicle.core.io.IORuntimeException - if the bytesConsumer encounters an IO error
    
    IllegalStateException - if a required state for this operation is not met
  - readWithLength
```
default void readWithLength(long length,
                            @NotNull
                            @NotNull net.openhft.chronicle.core.util.ThrowingConsumer<S,net.openhft.chronicle.core.io.IORuntimeException> bytesConsumer)
                     throws BufferUnderflowException,
                            net.openhft.chronicle.core.io.IORuntimeException,
                            IllegalStateException
```
    Perform a set of actions within a temporary bounds mode. The bounds are defined by the specified length. After the consumer has been executed, the original read limit is restored and the read position is moved forward by the specified length.
    
    Parameters:
    
    length - the length to set the temporary bounds to
    
    bytesConsumer - the consumer to execute within the temporary bounds
    
    Throws:
    
    BufferUnderflowException - if the specified length is greater than the number of bytes remaining to read
    
    net.openhft.chronicle.core.io.IORuntimeException - if the bytesConsumer encounters an IO error
    
    IllegalStateException - if a required state for this operation is not met
  - inputStream
```
@NotNull
default @NotNull InputStream inputStream()
```
    Provides an InputStream for the data represented by this StreamingDataInput.
    
    Returns:
    
    an InputStream over the underlying data
  - readStopBit
```
default long readStopBit()
                  throws net.openhft.chronicle.core.io.IORuntimeException,
                         IllegalStateException,
                         BufferUnderflowException
```
    Reads a variable-length integer encoded using the stop bit encoding. This method is equivalent to calling BytesInternal.readStopBit(this).
    
    Returns:
    
    the decoded integer
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if an I/O error occurs
    
    IllegalStateException - if a required state for this operation is not met
    
    BufferUnderflowException - if there's not enough data to read
  - readStopBitChar
```
default char readStopBitChar()
                      throws net.openhft.chronicle.core.io.IORuntimeException,
                             IllegalStateException,
                             BufferUnderflowException
```
    Reads a variable-length character encoded using the stop bit encoding. This method is equivalent to calling BytesInternal.readStopBitChar(this).
    
    Returns:
    
    the decoded character
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if an I/O error occurs
    
    IllegalStateException - if a required state for this operation is not met
    
    BufferUnderflowException - if there's not enough data to read
  - readStopBitDouble
```
default double readStopBitDouble()
                          throws IllegalStateException
```
    Reads a variable-length double encoded using the stop bit encoding. This method is equivalent to calling BytesInternal.readStopBitDouble(this).
    
    Returns:
    
    the decoded double
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - readStopBitDecimal
```
default double readStopBitDecimal()
                           throws IllegalStateException,
                                  BufferUnderflowException
```
    Reads a decimal number represented as a variable-length double and scale encoded using the stop bit encoding. The absolute value of the returned double represents the value of the decimal, and the sign represents the sign of the decimal.
    
    Returns:
    
    the decoded decimal number
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
    
    BufferUnderflowException - if there's not enough data to read
  - readBoolean
```
default boolean readBoolean()
                     throws IllegalStateException
```
    Reads a boolean value from the input stream. It reads a byte and converts it into a boolean using BytesUtil.byteToBoolean(b).
    
    Returns:
    
    the boolean value
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - readByte
```
byte readByte()
       throws IllegalStateException
```
    Reads a byte value from the input stream.
    
    Returns:
    
    the byte value
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - rawReadByte
```
default byte rawReadByte()
                  throws IllegalStateException
```
    Reads a raw byte value from the input stream. The main difference between this method and readByte() is that the latter might perform additional processing or checks.
    
    Returns:
    
    the raw byte value
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - readChar
```
default char readChar()
               throws IllegalStateException,
                      BufferUnderflowException
```
    Reads a character value from the input stream. The character is read using the stop bit encoding.
    
    Returns:
    
    the character value
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
    
    BufferUnderflowException - if there's not enough data to read
  - readUnsignedByte
```
int readUnsignedByte()
              throws IllegalStateException
```
    Reads the next unsigned 8-bit value from the input stream. If there is no byte available, it returns -1.
    
    Returns:
    
    the next unsigned 8-bit value or -1
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - uncheckedReadUnsignedByte
```
int uncheckedReadUnsignedByte()
```
    Reads the next unsigned 8-bit value from the input stream without performing boundary checks. If there is no byte available, it returns -1. Use this method with caution as it bypasses checks for data availability.
    
    Returns:
    
    the next unsigned 8-bit value or -1
  - readShort
```
short readShort()
         throws BufferUnderflowException,
                IllegalStateException
```
    Reads a 16-bit short value from the input stream.
    
    Returns:
    
    the 16-bit short value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readUnsignedShort
```
default int readUnsignedShort()
                       throws BufferUnderflowException,
                              IllegalStateException
```
    Reads a 16-bit value from the input stream and converts it to an unsigned short by masking the sign bit.
    
    Returns:
    
    the unsigned 16-bit value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readInt24
```
default int readInt24()
               throws BufferUnderflowException,
                      IllegalStateException
```
    Reads a 24-bit signed integer value from the input stream. This is achieved by reading an unsigned short and an unsigned byte, and then bit-shifting and combining them to form a 24-bit integer.
    
    Returns:
    
    the 24-bit integer value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readUnsignedInt24
```
default int readUnsignedInt24()
                       throws BufferUnderflowException,
                              IllegalStateException
```
    Reads a 24-bit unsigned integer value from the input stream. This is achieved by reading an unsigned short and an unsigned byte, and then bit-shifting and combining them to form a 24-bit unsigned integer.
    
    Returns:
    
    the 24-bit unsigned integer value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readInt
```
int readInt()
     throws BufferUnderflowException,
            IllegalStateException
```
    Reads a 32-bit integer value from the input stream.
    
    Returns:
    
    the 32-bit integer value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - rawReadInt
```
default int rawReadInt()
                throws BufferUnderflowException,
                       IllegalStateException
```
    Reads a 32-bit integer value from the input stream without performing boundary checks. Use this method with caution as it bypasses checks for data availability.
    
    Returns:
    
    the 32-bit integer value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readUnsignedInt
```
default long readUnsignedInt()
                      throws BufferUnderflowException,
                             IllegalStateException
```
    Reads a 32-bit value from the input stream and converts it to an unsigned integer by masking the sign bit.
    
    Returns:
    
    the unsigned 32-bit integer value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readLong
```
long readLong()
       throws BufferUnderflowException,
              IllegalStateException
```
    Reads a 64-bit long value from the input stream.
    
    Returns:
    
    the 64-bit long value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - rawReadLong
```
default long rawReadLong()
                  throws BufferUnderflowException,
                         IllegalStateException
```
    Reads a 64-bit long value from the input stream without performing boundary checks. Use this method with caution as it bypasses checks for data availability.
    
    Returns:
    
    the 64-bit long value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readIncompleteLong
```
default long readIncompleteLong()
                         throws IllegalStateException
```
    Returns:
    
    a long using the bytes remaining
    
    Throws:
    
    IllegalStateException - if released
  - readFloat
```
float readFloat()
         throws BufferUnderflowException,
                IllegalStateException
```
    Reads a 32-bit floating-point number from the input stream.
    
    Returns:
    
    the float value read from the stream
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readDouble
```
double readDouble()
           throws BufferUnderflowException,
                  IllegalStateException
```
    Reads a 64-bit floating-point number from the input stream.
    
    Returns:
    
    the double value read from the stream
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readUtf8
```
@Nullable
default @Nullable String readUtf8()
                                     throws BufferUnderflowException,
                                            net.openhft.chronicle.core.io.IORuntimeException,
                                            IllegalStateException,
                                            ArithmeticException
```
    Reads a UTF-8 encoded string from the input stream. This method supports null values and utilizes stop bit encoding for length, saving one byte for strings shorter than 128 characters.
    
    Returns:
    
    a Unicode string or null if writeUtf8(null) was called
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    net.openhft.chronicle.core.io.IORuntimeException - if an IO error occurs
    
    IllegalStateException - if a required state for this operation is not met
    
    ArithmeticException - if numeric overflow or underflow occurs
  - read8bit
```
@Nullable
default @Nullable String read8bit()
                                     throws net.openhft.chronicle.core.io.IORuntimeException,
                                            BufferUnderflowException,
                                            IllegalStateException,
                                            ArithmeticException
```
    Reads an 8-bit encoded string from the input stream.
    
    Returns:
    
    an 8-bit string or null if write8bit(null) was called
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    net.openhft.chronicle.core.io.IORuntimeException - if an IO error occurs
    
    IllegalStateException - if a required state for this operation is not met
    
    ArithmeticException - if numeric overflow or underflow occurs
  - readUtf8
```
default <C extends Appendable & CharSequence> boolean readUtf8(@NotNull
                                                               C sb)
                                                        throws net.openhft.chronicle.core.io.IORuntimeException,
                                                               BufferUnderflowException,
                                                               ArithmeticException,
                                                               IllegalStateException,
                                                               IllegalArgumentException
```
    Reads a UTF-8 encoded string from the input stream and appends it to the provided appendable. This method is similar to readUtf8(), except it populates a provided appendable instead of creating a new string.
    
    Parameters:
    
    sb - the appendable to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if an IO error occurs
    
    BufferUnderflowException - if there's not enough data to read
    
    ArithmeticException - if numeric overflow or underflow occurs
    
    IllegalStateException - if a required state for this operation is not met
    
    IllegalArgumentException - if the appendable does not allow setting length
  - readUtf8
```
default boolean readUtf8(@NotNull
                         @NotNull Bytes<?> sb)
                  throws net.openhft.chronicle.core.io.IORuntimeException,
                         BufferUnderflowException,
                         ArithmeticException,
                         IllegalStateException
```
    Reads a UTF-8 encoded string from the input stream and appends it to the provided Bytes. This method is similar to readUtf8(), except it populates a provided Bytes instance instead of creating a new string.
    
    Parameters:
    
    sb - the Bytes instance to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if an IO error occurs
    
    BufferUnderflowException - if there's not enough data to read
    
    ArithmeticException - if numeric overflow or underflow occurs
    
    IllegalStateException - if a required state for this operation is not met
  - readUtf8
```
default boolean readUtf8(@NotNull
                         @NotNull StringBuilder sb)
                  throws net.openhft.chronicle.core.io.IORuntimeException,
                         BufferUnderflowException,
                         ArithmeticException,
                         IllegalStateException
```
    Reads a UTF-8 encoded string from the input stream and appends it to the provided StringBuilder. This method is similar to readUtf8(), except it populates a provided StringBuilder instead of creating a new string.
    
    Parameters:
    
    sb - the StringBuilder to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if an IO error occurs
    
    BufferUnderflowException - if there's not enough data to read
    
    ArithmeticException - if numeric overflow or underflow occurs
    
    IllegalStateException - if a required state for this operation is not met
  - read8bit
```
default boolean read8bit(@NotNull
                         @NotNull Bytes<?> b)
                  throws BufferUnderflowException,
                         IllegalStateException,
                         ArithmeticException,
                         BufferOverflowException
```
    Reads an 8-bit encoded string from the input stream and appends it to the provided Bytes.
    
    Parameters:
    
    b - the Bytes instance to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
    
    ArithmeticException - if numeric overflow or underflow occurs
    
    BufferOverflowException - if the buffer is full
  - read8bit
```
default boolean read8bit(@NotNull
                         @NotNull StringBuilder sb)
                  throws net.openhft.chronicle.core.io.IORuntimeException,
                         BufferUnderflowException,
                         ArithmeticException,
                         IllegalStateException
```
    Reads an 8-bit encoded string from the input stream and appends it to the provided StringBuilder.
    
    Parameters:
    
    sb - the StringBuilder to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if an IO error occurs
    
    BufferUnderflowException - if there's not enough data to read
    
    ArithmeticException - if numeric overflow or underflow occurs
    
    IllegalStateException - if a required state for this operation is not met
  - read
```
default int read(byte[] bytes)
          throws BufferUnderflowException,
                 IllegalStateException
```
    Reads the input stream into the provided byte array.
    
    Parameters:
    
    bytes - the byte array to fill with the read data
    
    Returns:
    
    the number of bytes read, or -1 if the end of the stream is reached
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - read
```
default int read(byte[] bytes,
                 int off,
                 int len)
          throws BufferUnderflowException,
                 IllegalStateException
```
    Reads the input stream into the provided byte array, starting from the given offset and reading up to the specified length.
    
    Parameters:
    
    bytes - the byte array to fill with the read data
    
    off - the start offset in the byte array
    
    len - the maximum number of bytes to read
    
    Returns:
    
    the number of bytes read, or -1 if the end of the stream is reached
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - read
```
default int read(char[] bytes,
                 int off,
                 int len)
          throws IllegalStateException
```
    Reads the input stream into the provided char array, starting from the given offset and reading up to the specified length.
    
    Parameters:
    
    bytes - the char array to fill with the read data
    
    off - the start offset in the char array
    
    len - the maximum number of chars to read
    
    Returns:
    
    the number of chars read, or -1 if the end of the stream is reached
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - read
```
default void read(@NotNull
                  @NotNull ByteBuffer buffer)
           throws IllegalStateException
```
    Reads the input stream into the provided ByteBuffer.
    
    Parameters:
    
    buffer - the ByteBuffer to fill with the read data
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - read
```
default void read(@NotNull
                  @NotNull Bytes<?> bytes)
```
    Transfers as many bytes as possible from the input stream into the provided Bytes object.
    
    Parameters:
    
    bytes - the Bytes object to fill with the read data
    
    See Also:
    
    StreamingDataOutput.write(BytesStore)
  - read
```
default void read(@NotNull
                  @NotNull Bytes<?> bytes,
                  int length)
           throws BufferUnderflowException,
                  BufferOverflowException,
                  IllegalStateException
```
    Transfers the specified number of bytes from the input stream into the provided Bytes object.
    
    Parameters:
    
    bytes - the Bytes object to fill with the read data
    
    length - the number of bytes to read
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    BufferOverflowException - if there's not enough space in the provided Bytes object
    
    IllegalStateException - if a required state for this operation is not met
  - unsafeReadObject
```
default void unsafeReadObject(@NotNull
                              @NotNull Object o,
                              int length)
                       throws BufferUnderflowException,
                              IllegalStateException
```
    Reads data from the input stream into the provided object.
    
    Parameters:
    
    o - the object to fill with the read data
    
    length - the number of bytes to read
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - unsafeReadObject
```
default void unsafeReadObject(@NotNull
                              @NotNull Object o,
                              int offset,
                              int length)
                       throws BufferUnderflowException,
                              IllegalStateException
```
    Reads data from the input stream into the provided object, starting from the given offset.
    
    Parameters:
    
    o - the object to fill with the read data
    
    offset - the start offset in the object
    
    length - the number of bytes to read
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - unsafeRead
```
default S unsafeRead(long address,
                     int length)
```
    Reads data from the input stream into the memory at the provided address.
    
    Parameters:
    
    address - the address of the memory to fill with the read data
    
    length - the number of bytes to read
    
    Returns:
    
    a reference to this object
  - readVolatileInt
```
int readVolatileInt()
             throws BufferUnderflowException,
                    IllegalStateException
```
    Reads a volatile (concurrently mutable) integer value from the input stream.
    
    Returns:
    
    the read integer value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - readVolatileLong
```
long readVolatileLong()
               throws BufferUnderflowException,
                      IllegalStateException
```
    Reads a volatile (concurrently mutable) long value from the input stream.
    
    Returns:
    
    the read long value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - peekUnsignedByte
```
int peekUnsignedByte()
              throws IllegalStateException
```
    Peeks (reads without moving the read pointer) the next unsigned byte from the input stream.
    
    Returns:
    
    the peeked byte value
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - readEnum
```
@NotNull
default <E extends Enum<E>> E readEnum(@NotNull
                                                @NotNull Class<E> eClass)
                                         throws net.openhft.chronicle.core.io.IORuntimeException,
                                                BufferUnderflowException,
                                                ArithmeticException,
                                                IllegalStateException,
                                                BufferOverflowException
```
    Reads an Enum value from the input stream.
    
    Parameters:
    
    eClass - the class of the Enum
    
    Returns:
    
    the read Enum value
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - if an I/O error occurs
    
    BufferUnderflowException - if there's not enough data to read
    
    ArithmeticException - if the number format is invalid
    
    IllegalStateException - if a required state for this operation is not met
    
    BufferOverflowException - if there's not enough space in the buffer
  - parseUtf8
```
default void parseUtf8(@NotNull
                       @NotNull Appendable sb,
                       int encodedLength)
                throws IllegalArgumentException,
                       BufferUnderflowException,
                       UTFDataFormatRuntimeException,
                       IllegalStateException
```
    Parses a UTF-8 string from the input stream into the provided Appendable.
    
    Parameters:
    
    sb - the Appendable to fill with the parsed string
    
    encodedLength - the length of the UTF-8 encoded data in bytes
    
    Throws:
    
    IllegalArgumentException - if an illegal argument is provided
    
    BufferUnderflowException - if there's not enough data to read
    
    UTFDataFormatRuntimeException - if the string is not valid UTF-8
    
    IllegalStateException - if a required state for this operation is not met
  - parseUtf8
```
default void parseUtf8(@NotNull
                       @NotNull Appendable sb,
                       boolean utf,
                       int length)
                throws IllegalArgumentException,
                       BufferUnderflowException,
                       UTFDataFormatRuntimeException,
                       IllegalStateException
```
    Parses a UTF-8 string from the input stream into the provided Appendable.
    
    Parameters:
    
    sb - the Appendable to fill with the parsed string
    
    utf - true if the length is the UTF-8 encoded length, false if the length is the length of chars
    
    length - the maximum number of bytes to read
    
    Throws:
    
    IllegalArgumentException - if an illegal argument is provided
    
    BufferUnderflowException - if there's not enough data to read
    
    UTFDataFormatRuntimeException - if the string is not valid UTF-8
    
    IllegalStateException - if a required state for this operation is not met
  - parseHexLong
```
default long parseHexLong()
                   throws BufferUnderflowException,
                          IllegalStateException
```
    Parses a hexadecimal long value from the input stream.
    
    Returns:
    
    the parsed long value
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
  - copyTo
```
void copyTo(@NotNull
            @NotNull OutputStream out)
     throws IOException,
            IllegalStateException
```
    Copies the data from the input stream to the provided OutputStream.
    
    Parameters:
    
    out - the OutputStream to copy the data to
    
    Throws:
    
    IOException - if an I/O error occurs
    
    IllegalStateException - if a required state for this operation is not met
  - copyTo
```
long copyTo(@NotNull
            @NotNull BytesStore to)
     throws IllegalStateException
```
    Copies the data from the input stream to the provided BytesStore.
    
    Parameters:
    
    to - the BytesStore to copy the data to
    
    Returns:
    
    the number of bytes copied
    
    Throws:
    
    IllegalStateException - if a required state for this operation is not met
  - readHistogram
```
default void readHistogram(@NotNull
                           @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                    throws BufferUnderflowException,
                           IllegalStateException,
                           ArithmeticException
```
    Reads data from the input stream into the provided Histogram.
    
    Parameters:
    
    histogram - the Histogram to fill with data
    
    Throws:
    
    BufferUnderflowException - if there's not enough data to read
    
    IllegalStateException - if a required state for this operation is not met
    
    ArithmeticException - if the number format is invalid
  - readWithLength
```
default void readWithLength(@NotNull
                            @NotNull Bytes<?> bytes)
                     throws ArithmeticException,
                            BufferUnderflowException,
                            BufferOverflowException,
                            IllegalStateException
```
    Reads data from the input stream with specified length into the provided Bytes.
    
    Parameters:
    
    bytes - the Bytes to fill with data
    
    Throws:
    
    ArithmeticException - if the number format is invalid
    
    BufferUnderflowException - if there's not enough data to read
    
    BufferOverflowException - if there's not enough space in the buffer
    
    IllegalStateException - if a required state for this operation is not met
  - lenient
```
void lenient(boolean lenient)
```
    When there is no more data to read, return zero, false and empty string.
    
    Parameters:
    
    lenient - if true, return nothing rather than error.
  - lenient
```
boolean lenient()
```
  - readBigDecimal
```
@NotNull
default @NotNull BigDecimal readBigDecimal()
                                             throws ArithmeticException,
                                                    BufferUnderflowException,
                                                    IllegalStateException
```
    Creates and returns a new BigDecimal representing the contents of this Bytes object.
    If this Byte object is empty, an object equal to BigDecimal.ZERO is returned.
    
    Returns:
    
    a new BigDecimal
    
    Throws:
    
    ArithmeticException - if the content of this Bytes object could not be successfully converted
    
    BufferUnderflowException - if the content of this Bytes object is insufficient to be successfully converted
    
    IllegalStateException - if this Bytes object was previously released
  - readBigInteger
```
@NotNull
default @NotNull BigInteger readBigInteger()
                                             throws ArithmeticException,
                                                    BufferUnderflowException,
                                                    IllegalStateException
```
    Creates and returns a new BigInteger representing the contents of this Bytes object or BigInteger.ZERO if this Bytes object is empty.
    
    Returns:
    
    a new BigInteger
    
    Throws:
    
    ArithmeticException - if the content of this Bytes object could not be successfully converted
    
    BufferUnderflowException - if the content of this Bytes object is insufficient to be successfully converted
    
    IllegalStateException - if this Bytes object was previously released
  - start
```
default long start()
```
    Returns:
    
    The smallest position allowed in this buffer.
  - capacity
```
default long capacity()
```
    Returns:
    
    the highest limit allowed for this buffer.
  - realCapacity
```
default long realCapacity()
```
    Returns:
    
    the limit for this buffer without resizing
  - 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 StreamingDataInput<S extends StreamingDataInput<S>>

Field Summary

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

Method Summary

Methods inherited from interface net.openhft.chronicle.bytes.StreamingCommon

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

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

Method Detail

readPosition

readPositionUnlimited

readPositionRemaining

readLimit

readLimitToCapacity

readSkip

readPositionForHeader

uncheckedReadSkipOne

uncheckedReadSkipBackOne

readWithLength0

readWithLength

inputStream

readStopBit

readStopBitChar

readStopBitDouble

readStopBitDecimal

readBoolean

readByte

rawReadByte

readChar

readUnsignedByte

uncheckedReadUnsignedByte

readShort

readUnsignedShort

readInt24

readUnsignedInt24

readInt

rawReadInt

readUnsignedInt

readLong

rawReadLong

readIncompleteLong

readFloat

readDouble

readUtf8

read8bit

readUtf8

readUtf8

readUtf8

read8bit

read8bit

read

read

read

read

read

read

unsafeReadObject

unsafeReadObject

unsafeRead

readVolatileInt

readVolatileLong

peekUnsignedByte

readEnum

parseUtf8

parseUtf8

parseHexLong

copyTo

copyTo

readHistogram

readWithLength

lenient

lenient

readBigDecimal

readBigInteger

start

capacity

realCapacity

readPosition

writePosition

lengthWritten

readRemaining