StreamingDataOutput (OpenHFT/Chronicle-Bytes 1.10.0 API)

All Superinterfaces:

StreamingCommon<S>

All Known Subinterfaces:

Bytes<Underlying>, BytesOut<Underlying>, ByteStringAppender<B>

All Known Implementing Classes:

AbstractBytes, HexDumpBytes, MappedBytes, NativeBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface StreamingDataOutput<S extends StreamingDataOutput<S>>
extends StreamingCommon<S>
```
Position based access. Once data has been read, the position() moves.
The use of this instance is single threaded, though the use of the data

Field Summary

Fields
Modifier and Type Field and Description

static int JAVA9_STRING_CODER_LATIN

static int JAVA9_STRING_CODER_UTF16

Fields
Modifier and Type	Field and Description
`static int`	`JAVA9_STRING_CODER_LATIN`
`static int`	`JAVA9_STRING_CODER_UTF16`

Method Summary

All Methods Instance Methods Abstract Methods Default Methods Deprecated Methods
Modifier and Type	Method and Description
`long`	`addressForRead(long offset)` Obtain the underlying addressForRead.
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`default S`	`appendUtf8(byte[] bytes, int offset, int length)`
`default S`	`appendUtf8(byte[] bytes, int offset, int length, byte coder)`
`default S`	`appendUtf8(char[] chars, int offset, int length)`
`default S`	`appendUtf8(CharSequence cs)`
`default S`	`appendUtf8(CharSequence cs, int offset, int length)`
`default S`	`appendUtf8(int codepoint)`
`default ByteOrder`	`byteOrder()`
`Bytes`	`bytesForRead()`
`Bytes`	`bytesForWrite()`
`default long`	`capacity()`
`default boolean`	`compareAndSwapDouble(long offset, double expected, double value)` Perform a 64-bit double CAS at a given offset.
`default boolean`	`compareAndSwapFloat(long offset, float expected, float value)` Perform a 32-bit float CAS at a given offset.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Perform a 32-bit CAS at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Perform a 64-bit CAS at a given offset.
`default void`	`copyFrom(InputStream input)`
`boolean`	`isDirectMemory()`
`void`	`nativeWrite(long address, long size)` This is an expert level method for writing out data to native memory.
`default OutputStream`	`outputStream()`
`default long`	`readLimit()`
`default long`	`readPosition()` The read position must be start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
`default long`	`readRemaining()`
`long`	`realCapacity()`
`boolean`	`sharedMemory()`
`default long`	`start()`
`default S`	`write(byte[] bytes)`
`S`	`write(byte[] bytes, int offset, int length)` Write all data or fail.
`default S`	`write(BytesStore bytes)` Write all data or fail.
`default S`	`write(BytesStore bytes, long offset, long length)` Write all data or fail.
`default S`	`write(CharSequence cs)`
`default S`	`write(CharSequence s, int start, int length)`
`default S`	`write8bit(BytesStore bs)`
`default S`	`write8bit(CharSequence cs)`
`default S`	`write8bit(CharSequence s, int start, int length)`
`default S`	`write8bit(String s)`
`default void`	`writeBigDecimal(BigDecimal bd)`
`default void`	`writeBigInteger(BigInteger bi)`
`default S`	`writeBoolean(boolean flag)`
`S`	`writeByte(byte i8)`
`S`	`writeDouble(double d)`
`default <E extends Enum<E>> void`	`writeEnum(E e)`
`S`	`writeFloat(float f)`
`default void`	`writeHistogram(net.openhft.chronicle.core.util.Histogram histogram)`
`S`	`writeInt(int i)`
`default S`	`writeInt24(int i)`
`S`	`writeIntAdv(int i, int advance)`
`default long`	`writeLimit()`
`S`	`writeLimit(long limit)`
`S`	`writeLong(long i64)`
`S`	`writeLongAdv(long i64, int advance)`
`S`	`writeOrderedInt(int i)`
`S`	`writeOrderedLong(long i)`
`default long`	`writePosition()` The read position must be readPosition() <= writePosition() && writePosition() <= writeLimit()
`S`	`writePosition(long position)`
`default void`	`writePositionRemaining(long position, long length)`
`default long`	`writeRemaining()`
`S`	`writeShort(short i16)`
`S`	`writeSkip(long bytesToSkip)` Skip a number of bytes by moving the readPosition.
`S`	`writeSome(ByteBuffer buffer)`
`default S`	`writeSome(Bytes bytes)`
`default S`	`writeStopBit(double d)`
`default S`	`writeStopBit(long x)` Write a stop bit encoded long
`default S`	`writeStopBitDecimal(double d)`
`default S`	`writeUnsignedByte(int i)`
`default S`	`writeUnsignedInt(long i)`
`default S`	`writeUnsignedShort(int u16)`
`default S`	`writeUtf8(CharSequence cs)` Write the same encoding as `writeUTF` with the following changes.
`default S`	`writeUtf8(String s)`
`default S`	`writeUTFΔ(CharSequence cs)` Deprecated.
`default void`	`writeWithLength(BytesStore bytes)`

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

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

Field Detail
- JAVA9_STRING_CODER_LATIN
```
static final int JAVA9_STRING_CODER_LATIN
```
  See Also:
  
  Constant Field Values
- JAVA9_STRING_CODER_UTF16
```
static final int JAVA9_STRING_CODER_UTF16
```
  See Also:
  
  Constant Field Values

Method Detail

writePosition

@NotNull
S writePosition(long position)
                  throws BufferOverflowException

Throws:: BufferOverflowException

writeLimit

@NotNull
 @NotNull
S writeLimit(long limit)
                         throws BufferOverflowException

Throws:: BufferOverflowException

writeSkip
```
@NotNull
S writeSkip(long bytesToSkip)
              throws BufferOverflowException
```
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:

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

outputStream

@NotNull
 @NotNull
default OutputStream outputStream()

Returns:: Bytes as an OutputStream

writeStopBit

@NotNull
 @NotNull
default S writeStopBit(long x)
                                   throws BufferOverflowException

Write a stop bit encoded long

Parameters:: x - long to write
Returns:: this.
Throws:: BufferOverflowException

writeStopBit

@NotNull
 @NotNull
default S writeStopBit(double d)
                                   throws BufferOverflowException

Throws:: BufferOverflowException

writeStopBitDecimal

@NotNull
default S writeStopBitDecimal(double d)
                                throws BufferOverflowException

Throws:: BufferOverflowException

writeUtf8
```
@NotNull
 @NotNull
default S writeUtf8(CharSequence cs)
                                throws BufferOverflowException
```
Write the same encoding as writeUTF with the following changes. 1) The length is stop bit encoded i.e. one byte longer for short strings, but is not limited in length. 2) The string can be null.

Parameters:

cs - the string value to be written. Can be null.

Throws:

BufferOverflowException - if there is not enough space left

writeUtf8

@NotNull
 @NotNull
default S writeUtf8(String s)
                                throws BufferOverflowException

Throws:: BufferOverflowException

writeUTFΔ

@NotNull
 @NotNull
 @Deprecated
default S writeUTFΔ(CharSequence cs)
                                             throws BufferOverflowException

Deprecated.

Throws:: BufferOverflowException

write8bit

@NotNull
 @NotNull
default S write8bit(@Nullable
                                       CharSequence cs)
                                throws BufferOverflowException

Throws:: BufferOverflowException

write8bit

@NotNull
 @NotNull
default S write8bit(@NotNull @NotNull
                                       CharSequence s,
                                       int start,
                                       int length)
                                throws BufferOverflowException,
                                       IllegalArgumentException,
                                       IndexOutOfBoundsException

Throws:: BufferOverflowException; IllegalArgumentException; IndexOutOfBoundsException

write

@NotNull
 @NotNull
default S write(CharSequence cs)
                            throws BufferOverflowException,
                                   BufferUnderflowException,
                                   IllegalArgumentException

Throws:: BufferOverflowException; BufferUnderflowException; IllegalArgumentException

write

@NotNull
 @NotNull
default S write(@NotNull @NotNull
                                   CharSequence s,
                                   int start,
                                   int length)
                            throws BufferOverflowException,
                                   IllegalArgumentException,
                                   IndexOutOfBoundsException

Throws:: BufferOverflowException; IllegalArgumentException; IndexOutOfBoundsException

write8bit

@NotNull
 @NotNull
default S write8bit(@Nullable
                                       String s)
                                throws BufferOverflowException

Throws:: BufferOverflowException

write8bit

@NotNull
 @NotNull
default S write8bit(@Nullable
                                       BytesStore bs)
                                throws BufferOverflowException

Throws:: BufferOverflowException

writeByte

@NotNull
 @NotNull
S writeByte(byte i8)
                        throws BufferOverflowException

Throws:: BufferOverflowException

writeUnsignedByte

@NotNull
 @NotNull
default S writeUnsignedByte(int i)
                                        throws BufferOverflowException,
                                               IllegalArgumentException

Throws:: BufferOverflowException; IllegalArgumentException

writeShort

@NotNull
 @NotNull
S writeShort(short i16)
                         throws BufferOverflowException

Throws:: BufferOverflowException

writeUnsignedShort

@NotNull
 @NotNull
default S writeUnsignedShort(int u16)
                                         throws BufferOverflowException,
                                                IllegalArgumentException

Throws:: BufferOverflowException; IllegalArgumentException

writeInt24

@NotNull
 @NotNull
default S writeInt24(int i)
                                 throws BufferOverflowException

Throws:: BufferOverflowException

writeInt

@NotNull
 @NotNull
S writeInt(int i)
                       throws BufferOverflowException

Throws:: BufferOverflowException

writeIntAdv

@NotNull
 @NotNull
S writeIntAdv(int i,
                                 int advance)
                          throws BufferOverflowException

Throws:: BufferOverflowException

writeUnsignedInt

@NotNull
 @NotNull
default S writeUnsignedInt(long i)
                                       throws BufferOverflowException,
                                              IllegalArgumentException

Throws:: BufferOverflowException; IllegalArgumentException

writeLong

@NotNull
 @NotNull
S writeLong(long i64)
                        throws BufferOverflowException

Throws:: BufferOverflowException

writeLongAdv

@NotNull
 @NotNull
S writeLongAdv(long i64,
                                  int advance)
                           throws BufferOverflowException

Throws:: BufferOverflowException

writeFloat

@NotNull
 @NotNull
S writeFloat(float f)
                         throws BufferOverflowException

Throws:: BufferOverflowException

writeDouble

@NotNull
 @NotNull
S writeDouble(double d)
                          throws BufferOverflowException

Throws:: BufferOverflowException

write

@NotNull
 @NotNull
default S write(@NotNull @NotNull
                                   BytesStore bytes)

Write all data or fail.

realCapacity
```
long realCapacity()
```

writeSome

@NotNull
 @NotNull
default S writeSome(@NotNull @NotNull
                                       Bytes bytes)

write

@NotNull
 @NotNull
default S write(@NotNull @NotNull
                                   BytesStore bytes,
                                   long offset,
                                   long length)
                            throws BufferOverflowException,
                                   BufferUnderflowException

Write all data or fail.

Throws:: BufferOverflowException; BufferUnderflowException

write

@NotNull
 @NotNull
default S write(@NotNull @NotNull
                                   byte[] bytes)
                            throws BufferOverflowException

Throws:: BufferOverflowException

write

@NotNull
 @NotNull
S write(byte[] bytes,
                           int offset,
                           int length)
                    throws BufferOverflowException

Write all data or fail.

Throws:: BufferOverflowException

writeSome

@NotNull
 @NotNull
S writeSome(ByteBuffer buffer)
                        throws BufferOverflowException

Throws:: BufferOverflowException

writeBoolean

@NotNull
 @NotNull
default S writeBoolean(boolean flag)
                                   throws BufferOverflowException

Throws:: BufferOverflowException

writeOrderedInt

@NotNull
 @NotNull
S writeOrderedInt(int i)
                              throws BufferOverflowException

Throws:: BufferOverflowException

writeOrderedLong

@NotNull
 @NotNull
S writeOrderedLong(long i)
                               throws BufferOverflowException

Throws:: BufferOverflowException

nativeWrite
```
void nativeWrite(long address,
                 long size)
          throws BufferOverflowException
```
This is an expert level method for writing out data to native memory.

Parameters:

address - to write to.

size - in bytes.

Throws:

BufferOverflowException

writeEnum

default <E extends Enum<E>> void writeEnum(@NotNull @NotNull
                                           E e)
                                    throws BufferOverflowException

Throws:: BufferOverflowException

appendUtf8

@NotNull
 @NotNull
default S appendUtf8(@NotNull @NotNull
                                        CharSequence cs)
                                 throws BufferOverflowException

Throws:: BufferOverflowException

appendUtf8

@NotNull
 @NotNull
default S appendUtf8(int codepoint)
                                 throws BufferOverflowException

Throws:: BufferOverflowException

appendUtf8

@NotNull
default S appendUtf8(char[] chars,
                              int offset,
                              int length)
                       throws BufferOverflowException,
                              IllegalArgumentException

Throws:: BufferOverflowException; IllegalArgumentException

appendUtf8

@NotNull
 @NotNull
default S appendUtf8(@NotNull @NotNull
                                        CharSequence cs,
                                        int offset,
                                        int length)
                                 throws BufferOverflowException,
                                        IllegalArgumentException

Throws:: BufferOverflowException; IllegalArgumentException

appendUtf8

@NotNull
default S appendUtf8(byte[] bytes,
                              int offset,
                              int length,
                              byte coder)
                       throws BufferOverflowException,
                              IllegalArgumentException

Throws:: BufferOverflowException; IllegalArgumentException

appendUtf8

@NotNull
default S appendUtf8(byte[] bytes,
                              int offset,
                              int length)
                       throws BufferOverflowException,
                              IllegalArgumentException

Throws:: BufferOverflowException; IllegalArgumentException

copyFrom

default void copyFrom(@NotNull @NotNull
                      InputStream input)
               throws IOException,
                      BufferOverflowException,
                      IllegalArgumentException

Throws:: IOException; BufferOverflowException; IllegalArgumentException

writePositionRemaining

default void writePositionRemaining(long position,
                                    long length)

writeHistogram

default void writeHistogram(@NotNull @NotNull
                            net.openhft.chronicle.core.util.Histogram histogram)

writeBigDecimal

default void writeBigDecimal(@NotNull @NotNull
                             BigDecimal bd)

writeBigInteger

default void writeBigInteger(@NotNull @NotNull
                             BigInteger bi)

writeWithLength

default void writeWithLength(BytesStore bytes)

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

The smallest position allowed in this buffer.

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

the highest limit allowed for this buffer.

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

Returns:

position to read from.

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

Returns:

position to write to.

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

How many more bytes can we read.

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

How many more bytes can we written.

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

the highest offset or position allowed for this buffer.

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

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

Parameters:

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

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

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

addressForWrite
```
long addressForWrite(long offset)
              throws UnsupportedOperationException,
                     BufferOverflowException
```
Obtain the underlying addressForRead. This is for expert users only.

Parameters:

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

Returns:

the underlying addressForRead of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

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

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

bytesForRead

@NotNull
Bytes bytesForRead()
                     throws IllegalStateException

Returns:: the streaming bytes for reading.
Throws:: IllegalStateException

bytesForWrite

@NotNull
Bytes bytesForWrite()
                      throws IllegalStateException

Returns:: the streaming bytes for writing.
Throws:: IllegalStateException

compareAndSwapInt
```
boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException
```
Perform a 32-bit CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

compareAndSwapLong

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

Perform a 64-bit CAS at a given offset.

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

compareAndSwapFloat

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

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

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

compareAndSwapDouble

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

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

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

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

true if these Bytes use shared memory.

isDirectMemory
```
boolean isDirectMemory()
```

Interface StreamingDataOutput<S extends StreamingDataOutput<S>>

Field Summary

Method Summary

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

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

Field Detail

JAVA9_STRING_CODER_LATIN

JAVA9_STRING_CODER_UTF16

Method Detail

writePosition

writeLimit

writeSkip

outputStream

writeStopBit

writeStopBit

writeStopBitDecimal

writeUtf8

writeUtf8

writeUTFΔ

write8bit

write8bit

write

write

write8bit

write8bit

writeByte

writeUnsignedByte

writeShort

writeUnsignedShort

writeInt24

writeInt

writeIntAdv

writeUnsignedInt

writeLong

writeLongAdv

writeFloat

writeDouble

write

realCapacity

writeSome

write

write

write

writeSome

writeBoolean

writeOrderedInt

writeOrderedLong

nativeWrite

writeEnum

appendUtf8

appendUtf8

appendUtf8

appendUtf8

appendUtf8

appendUtf8

copyFrom

writePositionRemaining

writeHistogram

writeBigDecimal

writeBigInteger

writeWithLength

start

capacity

readPosition

writePosition

readRemaining

writeRemaining

readLimit

writeLimit

addressForRead

addressForWrite

byteOrder

bytesForRead

bytesForWrite

compareAndSwapInt

compareAndSwapLong

compareAndSwapFloat

compareAndSwapDouble

sharedMemory

isDirectMemory