StreamingDataInput (OpenHFT/Chronicle-Bytes 1.7.14 API)

All Known Subinterfaces:

Bytes<Underlying>, BytesIn<Underlying>, net.openhft.chronicle.bytes.ByteStringParser<B>

All Known Implementing Classes:

AbstractBytes, CheckingMappedBytes, MappedBytes, NativeBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface StreamingDataInput<S extends StreamingDataInput<S>>
```
This data input has a a position() and a limit()

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`address(long offset)` Obtain the underlying address.
`default ByteOrder`	`byteOrder()`
`Bytes`	`bytesForRead()`
`Bytes`	`bytesForWrite()`
`default long`	`capacity()`
`S`	`clear()` Set the readPosition= writePosition = start, writeLimit = capacity
`default boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Perform a 64-bit double CAS at a given offset.
`default boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Perform a 32-bit float CAS at a given offset.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`long`	`copyTo(BytesStore to)`
`void`	`copyTo(OutputStream out)`
`default InputStream`	`inputStream()`
`boolean`	`isDirectMemory()`
`void`	`nativeRead(long address, long size)` This is an expert level method for copying raw native memory in bulk.
`default long`	`parseHexLong()`
`default void`	`parseUTF(Appendable sb, int length)` Deprecated.
`default void`	`parseUtf8(Appendable sb, int length)`
`int`	`peekUnsignedByte()`
`default int`	`read(byte[] bytes)`
`default int`	`read(byte[] bytes, int off, int len)`
`default void`	`read(ByteBuffer buffer)`
`default int`	`read(char[] bytes, int off, int len)`
`default String`	`read8bit()`
`default <ACS extends Appendable & CharSequence> boolean`	`read8bit(ACS sb)`
`default boolean`	`read8bit(Bytes b)`
`default boolean`	`read8bit(StringBuilder sb)`
`default boolean`	`readBoolean()`
`byte`	`readByte()`
`double`	`readDouble()`
`default <E extends Enum<E>> E`	`readEnum(Class<E> eClass)`
`float`	`readFloat()`
`int`	`readInt()`
`default long`	`readLimit()`
`S`	`readLimit(long limit)`
`long`	`readLong()`
`default long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`S`	`readPosition(long position)`
`default S`	`readPositionRemaining(long position, long remaining)`
`default S`	`readPositionUnlimited(long position)`
`default long`	`readRemaining()`
`short`	`readShort()`
`S`	`readSkip(long bytesToSkip)` Skip a number of bytes by moving the readPosition.
`default long`	`readStopBit()`
`default double`	`readStopBitDouble()`
`int`	`readUnsignedByte()`
`default long`	`readUnsignedInt()`
`default int`	`readUnsignedInt24()`
`default int`	`readUnsignedShort()`
`default String`	`readUtf8()` The same as readUTF() except the length is stop bit encoded.
`default <ACS extends Appendable & CharSequence> boolean`	`readUtf8(ACS sb)` The same as readUtf8() except the chars are copied to a truncated StringBuilder.
`default String`	`readUTFΔ()` Deprecated.
`default <ACS extends Appendable & CharSequence> boolean`	`readUTFΔ(ACS sb)` Deprecated.
`int`	`readVolatileInt()`
`long`	`readVolatileLong()`
`default void`	`readWithLength(long length, net.openhft.chronicle.core.util.ThrowingConsumer<S,net.openhft.chronicle.core.io.IORuntimeException> bytesConsumer)` Perform a set of actions with a temporary bounds mode.
`boolean`	`sharedMemory()`
`default long`	`start()`
`void`	`uncheckedReadSkipBackOne()` Read skip -1 when you are sure this is safe.
`void`	`uncheckedReadSkipOne()` Read skip 1 when you are sure this is safe.
`int`	`uncheckedReadUnsignedByte()`
`default long`	`writeLimit()`
`default long`	`writePosition()` The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
`default long`	`writeRemaining()`

Methods inherited from interface net.openhft.chronicle.core.ReferenceCounted
refCount, release, release, releaseAll, reserve, tryReserve

Method Detail

readPosition

S readPosition(long position)
        throws BufferUnderflowException

Throws:: BufferUnderflowException

readPositionUnlimited

default S readPositionUnlimited(long position)
                         throws BufferUnderflowException

Throws:: BufferUnderflowException

readPositionRemaining

default S readPositionRemaining(long position,
                                long remaining)
                         throws BufferUnderflowException

Throws:: BufferUnderflowException

readLimit

S readLimit(long limit)
     throws BufferUnderflowException

Throws:: BufferUnderflowException

readSkip
```
S readSkip(long bytesToSkip)
    throws BufferUnderflowException
```
Skip a number of bytes by moving the readPosition. Must be less than or equal to the readLimit.

Parameters:

bytesToSkip - bytes to skip.

Returns:

this

Throws:

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

uncheckedReadSkipOne
```
void uncheckedReadSkipOne()
```
Read skip 1 when you are sure this is safe. Use at your own risk when you find a performance problem.

uncheckedReadSkipBackOne
```
void uncheckedReadSkipBackOne()
```
Read skip -1 when you are sure this is safe. Use at your own risk when you find a performance problem.

readWithLength

default void readWithLength(long length,
                            @NotNull
                            net.openhft.chronicle.core.util.ThrowingConsumer<S,net.openhft.chronicle.core.io.IORuntimeException> bytesConsumer)
                     throws BufferUnderflowException,
                            net.openhft.chronicle.core.io.IORuntimeException

Perform a set of actions with a temporary bounds mode.

Throws:: BufferUnderflowException; net.openhft.chronicle.core.io.IORuntimeException

inputStream

@NotNull
default InputStream inputStream()

readStopBit

default long readStopBit()
                  throws net.openhft.chronicle.core.io.IORuntimeException

Throws:: net.openhft.chronicle.core.io.IORuntimeException

readStopBitDouble
```
default double readStopBitDouble()
```

readBoolean
```
default boolean readBoolean()
```

readByte
```
byte readByte()
```

readUnsignedByte
```
int readUnsignedByte()
```
Returns:

the next unsigned 8 bit value or -1;

uncheckedReadUnsignedByte
```
int uncheckedReadUnsignedByte()
```
Returns:

the next unsigned 8 bit value or -1;

readShort

short readShort()
         throws BufferUnderflowException

Throws:: BufferUnderflowException

readUnsignedShort

default int readUnsignedShort()
                       throws BufferUnderflowException

Throws:: BufferUnderflowException

readUnsignedInt24

default int readUnsignedInt24()
                       throws BufferUnderflowException

Throws:: BufferUnderflowException

readInt

int readInt()
     throws BufferUnderflowException

Throws:: BufferUnderflowException

readUnsignedInt

default long readUnsignedInt()
                      throws BufferUnderflowException

Throws:: BufferUnderflowException

readLong

long readLong()
       throws BufferUnderflowException

Throws:: BufferUnderflowException

readFloat

float readFloat()
         throws BufferUnderflowException

Throws:: BufferUnderflowException

readDouble

double readDouble()
           throws BufferUnderflowException

Throws:: BufferUnderflowException

readUtf8
```
@Nullable
default String readUtf8()
                           throws BufferUnderflowException,
                                  net.openhft.chronicle.core.io.IORuntimeException,
                                  IllegalArgumentException
```
The same as readUTF() except the length is stop bit encoded. This saves one byte for strings shorter than 128 chars. null values are also supported

Returns:

a Unicode string or null if writeUtf8(null) was called

Throws:

BufferUnderflowException

net.openhft.chronicle.core.io.IORuntimeException

IllegalArgumentException

readUTFΔ

@Deprecated
default String readUTFΔ()
                             throws net.openhft.chronicle.core.io.IORuntimeException,
                                    BufferUnderflowException,
                                    IllegalArgumentException

Deprecated.

Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException; IllegalArgumentException

read8bit

@Nullable
default String read8bit()
                           throws net.openhft.chronicle.core.io.IORuntimeException,
                                  BufferUnderflowException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException

readUtf8

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

The same as readUtf8() except the chars are copied to a truncated StringBuilder.

Parameters:: sb - to copy chars to
Returns:: true if there was a String, or false if it was null
Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalArgumentException; BufferUnderflowException

readUTFΔ

@Deprecated
default <ACS extends Appendable & CharSequence> boolean readUTFΔ(@NotNull
                                                                             ACS sb)
                                                                      throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                             IllegalArgumentException,
                                                                             BufferUnderflowException

Deprecated.

Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalArgumentException; BufferUnderflowException

read8bit

default boolean read8bit(@NotNull
                         Bytes b)
                  throws net.openhft.chronicle.core.io.IORuntimeException,
                         IllegalArgumentException,
                         BufferUnderflowException,
                         IllegalStateException,
                         BufferOverflowException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalArgumentException; BufferUnderflowException; IllegalStateException; BufferOverflowException

read8bit

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

Throws:: net.openhft.chronicle.core.io.IORuntimeException; IllegalArgumentException; BufferUnderflowException

read8bit

default boolean read8bit(StringBuilder sb)
                  throws net.openhft.chronicle.core.io.IORuntimeException,
                         BufferUnderflowException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException

read

default int read(@NotNull
                 byte[] bytes)

read

default int read(@NotNull
                 byte[] bytes,
                 int off,
                 int len)

read

default int read(@NotNull
                 char[] bytes,
                 int off,
                 int len)

read

default void read(@NotNull
                  ByteBuffer buffer)

readVolatileInt

int readVolatileInt()
             throws BufferUnderflowException

Throws:: BufferUnderflowException

readVolatileLong

long readVolatileLong()
               throws BufferUnderflowException

Throws:: BufferUnderflowException

peekUnsignedByte
```
int peekUnsignedByte()
```

nativeRead
```
void nativeRead(long address,
                long size)
         throws BufferUnderflowException
```
This is an expert level method for copying raw native memory in bulk.

Parameters:

address - of the memory.

size - in bytes.

Throws:

BufferUnderflowException

readEnum

default <E extends Enum<E>> E readEnum(Class<E> eClass)
                                throws net.openhft.chronicle.core.io.IORuntimeException,
                                       BufferUnderflowException

Throws:: net.openhft.chronicle.core.io.IORuntimeException; BufferUnderflowException

parseUTF

@Deprecated
default void parseUTF(Appendable sb,
                                  int length)
                           throws IllegalArgumentException,
                                  BufferUnderflowException,
                                  UTFDataFormatRuntimeException

Deprecated.

Throws:: IllegalArgumentException; BufferUnderflowException; UTFDataFormatRuntimeException

parseUtf8

default void parseUtf8(Appendable sb,
                       int length)
                throws IllegalArgumentException,
                       BufferUnderflowException,
                       UTFDataFormatRuntimeException

Throws:: IllegalArgumentException; BufferUnderflowException; UTFDataFormatRuntimeException

parseHexLong
```
default long parseHexLong()
```

copyTo

void copyTo(OutputStream out)
     throws IOException

Throws:: IOException

copyTo
```
long copyTo(BytesStore to)
```

clear
```
@NotNull
S clear()
```
Set the readPosition= writePosition = start, writeLimit = capacity

Returns:

this

start
```
default long start()
```
Returns:

The smallest position allowed in this buffer.

capacity
```
default long capacity()
```
Returns:

the highest limit allowed for this buffer.

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

Returns:

position to read from.

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

Returns:

position to write to.

readRemaining
```
default long readRemaining()
```
Returns:

How many more bytes can we read.

writeRemaining
```
default long writeRemaining()
```
Returns:

How many more bytes can we written.

readLimit
```
default long readLimit()
```
Returns:

the highest offset or position allowed for this buffer.

writeLimit
```
default long writeLimit()
```

address
```
long address(long offset)
      throws UnsupportedOperationException,
             IllegalArgumentException
```
Obtain the underlying address. This is for expert users only.

Parameters:

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

Returns:

the underlying address of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

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

byteOrder
```
default ByteOrder byteOrder()
```

bytesForRead
```
Bytes bytesForRead()
            throws IllegalStateException
```
Returns:

the streaming bytes for reading.

Throws:

IllegalStateException

bytesForWrite
```
Bytes bytesForWrite()
             throws IllegalStateException
```
Returns:

the streaming bytes for writing.

Throws:

IllegalStateException

compareAndSwapInt

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

Perform a 32-bit CAS at a given offset.

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; IllegalArgumentException

compareAndSwapLong

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

Perform a 64-bit CAS at a given offset.

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; IllegalArgumentException

compareAndSwapFloat

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

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

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; IllegalArgumentException

compareAndSwapDouble

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

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

Parameters:: offset - to perform CAS; expected - value; value - to set
Returns:: true, if successful.
Throws:: BufferOverflowException; IllegalArgumentException

sharedMemory
```
boolean sharedMemory()
```
Returns:

true if these Bytes use shared memory.

isDirectMemory
```
boolean isDirectMemory()
```

Interface StreamingDataInput<S extends StreamingDataInput<S>>

Method Summary

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

Method Detail

readPosition

readPositionUnlimited

readPositionRemaining

readLimit

readSkip

uncheckedReadSkipOne

uncheckedReadSkipBackOne

readWithLength

inputStream

readStopBit

readStopBitDouble

readBoolean

readByte

readUnsignedByte

uncheckedReadUnsignedByte

readShort

readUnsignedShort

readUnsignedInt24

readInt

readUnsignedInt

readLong

readFloat

readDouble

readUtf8

readUTFΔ

read8bit

readUtf8

readUTFΔ

read8bit

read8bit

read8bit

read

read

read

read

readVolatileInt

readVolatileLong

peekUnsignedByte

nativeRead

readEnum

parseUTF

parseUtf8

parseHexLong

copyTo

copyTo

clear

start

capacity

readPosition

writePosition

readRemaining

writeRemaining

readLimit

writeLimit

address

byteOrder

bytesForRead

bytesForWrite

compareAndSwapInt

compareAndSwapLong

compareAndSwapFloat

compareAndSwapDouble

sharedMemory

isDirectMemory