StreamingDataOutput (OpenHFT/Chronicle-Bytes 2.21.93 API)

All Superinterfaces:

StreamingCommon<S>

All Known Subinterfaces:

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

All Known Implementing Classes:

AbstractBytes, EnbeddedBytes, GuardedNativeBytes, HexDumpBytes, MappedBytes, NativeBytes, NativeBytes.NativeSubBytes, OnHeapBytes, SubBytes, 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 inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
  INIT

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.
`default long`	`addressForRead(long offset, int buffer)`
`long`	`addressForWrite(long offset)` Obtain the underlying addressForRead.
`long`	`addressForWritePosition()`
`default S`	`alignBy(int width)` Deprecated.
`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(@NotNull CharSequence cs)`
`default S`	`appendUtf8(@NotNull CharSequence cs, int offset, int length)`
`default S`	`appendUtf8(int codepoint)`
`default ByteOrder`	`byteOrder()`
`@NotNull Bytes`	`bytesForRead()`
`@NotNull Bytes`	`bytesForWrite()`
`default boolean`	`canWriteDirect(long count)`
`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(@NotNull InputStream input)`
`boolean`	`isDirectMemory()`
`default @NotNull OutputStream`	`outputStream()`
`default S`	`rawWriteByte(byte i8)`
`default S`	`rawWriteInt(int i)`
`default S`	`rawWriteLong(long i)` Write a long without a bounds check
`default long`	`readLimit()`
`default long`	`readPosition()` The read position must be `start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()`
`default long`	`readRemaining()`
`long`	`realCapacity()`
`default long`	`realReadRemaining()`
`default long`	`realWriteRemaining()`
`boolean`	`sharedMemory()`
`default long`	`start()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`default S`	`unsafeWrite(long address, int length)` Write raw native memory for a ifixed length
`default S`	`unsafeWriteObject(Object o, int length)`
`default S`	`unsafeWriteObject(Object o, int offset, int length)`
`default S`	`write(@NotNull byte[] bytes)`
`S`	`write(byte[] bytes, int offset, int length)` Write all data or fail.
`default S`	`write(@NotNull BytesStore bytes)` Writes all the the passed BytesStore or it fails.
`default S`	`write(@NotNull BytesStore bytes, long offset, long length)` Write all data or fail.
`default S`	`write(CharSequence cs)`
`default S`	`write(@NotNull CharSequence s, int start, int length)`
`default S`	`write(@NotNull RandomDataInput bytes)` Write all data or fail.
`default S`	`write(@NotNull RandomDataInput bytes, long offset, long length)` Write all data or fail.
`default S`	`write8bit(@Nullable BytesStore bs)`
`default S`	`write8bit(@Nullable CharSequence cs)`
`default S`	`write8bit(@NotNull CharSequence s, int start, int length)`
`default S`	`write8bit(@Nullable String s)`
`S`	`write8bit(@NotNull String s, int start, int length)`
`default void`	`writeBigDecimal(@NotNull BigDecimal bd)`
`default void`	`writeBigInteger(@NotNull BigInteger bi)`
`default S`	`writeBoolean(boolean flag)`
`S`	`writeByte(byte i8)`
`default S`	`writeChar(char ch)`
`S`	`writeDouble(double d)`
`S`	`writeDoubleAndInt(double d, int i)`
`default <E extends Enum<E>> S`	`writeEnum(E e)`
`S`	`writeFloat(float f)`
`default void`	`writeHistogram(@NotNull 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)` Write a long
`S`	`writeLongAdv(long i64, int advance)`
`S`	`writeOrderedInt(int i)`
`S`	`writeOrderedLong(long i)`
`default long`	`writePosition()` The write position must be `readPosition() <= writePosition() && writePosition() <= writeLimit()`
`S`	`writePosition(long position)`
`default long`	`writePositionForHeader(boolean skipPadding)` obtain the writePosition skipping any padding needed for a header.
`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 writePosition.
`S`	`writeSome(ByteBuffer buffer)`
`default S`	`writeSome(@NotNull Bytes bytes)`
`default S`	`writeStopBit(char x)`
`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`	`writeUnsignedInt24(int 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(RandomDataInput bytes)`

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

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCounted
refCount, release, releaseLast, releaseLast, reserve, reservedBy, reserveTransfer, tryReserve

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceOwner
referenceId, referenceName, temporary

Field Detail
- 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
S writeLimit(long limit)
               throws BufferOverflowException

Throws:: BufferOverflowException

writeSkip
```
@NotNull
S writeSkip(long bytesToSkip)
              throws BufferOverflowException,
                     IllegalStateException
```
Skip a number of bytes by moving the writePosition. Must be less than or equal to the writeLimit.

Parameters:

bytesToSkip - bytes to skip. This can be negative.

Returns:

this

Throws:

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

IllegalStateException

alignBy

@Deprecated
default S alignBy(int width)
                       throws BufferOverflowException,
                              IllegalStateException

Deprecated.

Throws:: BufferOverflowException; IllegalStateException

writePositionForHeader
```
default long writePositionForHeader(boolean skipPadding)
```
obtain the writePosition skipping any padding needed for a header.

Parameters:

skipPadding - optional aligning to 4 bytes

Returns:

the write position.

outputStream

@NotNull
default @NotNull OutputStream outputStream()

Returns:: Bytes as an OutputStream

writeStopBit

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

Write a stop bit encoded long

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

writeStopBit

@NotNull
default S writeStopBit(char x)
                         throws BufferOverflowException,
                                IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeStopBit

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

Throws:: BufferOverflowException; IllegalStateException

writeStopBitDecimal

@NotNull
default S writeStopBitDecimal(double d)
                                throws BufferOverflowException,
                                       IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeUtf8
```
@NotNull
default S writeUtf8(CharSequence cs)
                      throws BufferOverflowException,
                             IllegalStateException,
                             IllegalArgumentException,
                             BufferUnderflowException
```
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

IllegalStateException

IllegalArgumentException

BufferUnderflowException

writeUtf8

@NotNull
default S writeUtf8(String s)
                      throws BufferOverflowException,
                             IllegalStateException,
                             BufferUnderflowException,
                             IllegalArgumentException

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException; IllegalArgumentException

writeUTFΔ

@NotNull
 @Deprecated
default S writeUTFΔ(CharSequence cs)
                                   throws BufferOverflowException,
                                          IllegalStateException,
                                          BufferUnderflowException,
                                          IllegalArgumentException

Deprecated.

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException; IllegalArgumentException

write8bit

@NotNull
default S write8bit(@Nullable
                             @Nullable CharSequence cs)
                      throws BufferOverflowException,
                             ArithmeticException,
                             IllegalStateException,
                             BufferUnderflowException

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException; BufferUnderflowException

write8bit

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

Throws:: BufferOverflowException; IndexOutOfBoundsException; ArithmeticException; IllegalStateException; BufferUnderflowException

write8bit

@NotNull
S write8bit(@NotNull
                     @NotNull String s,
                     int start,
                     int length)

write

@NotNull
default S write(CharSequence cs)
                  throws BufferOverflowException,
                         IndexOutOfBoundsException,
                         IllegalStateException

Throws:: BufferOverflowException; IndexOutOfBoundsException; IllegalStateException

write

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

Throws:: BufferOverflowException; IndexOutOfBoundsException; IllegalStateException

write8bit

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

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

write8bit

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

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException

writeByte

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

Throws:: BufferOverflowException; IllegalStateException

rawWriteByte

default S rawWriteByte(byte i8)
                throws BufferOverflowException,
                       IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeUnsignedByte

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

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

writeChar

@NotNull
default S writeChar(char ch)
                      throws BufferOverflowException,
                             IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeShort

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

Throws:: BufferOverflowException; IllegalStateException

writeUnsignedShort

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

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

writeInt24

@NotNull
default S writeInt24(int i)
                       throws BufferOverflowException,
                              ArithmeticException,
                              IllegalStateException

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

writeUnsignedInt24

@NotNull
default S writeUnsignedInt24(int i)
                               throws BufferOverflowException,
                                      ArithmeticException,
                                      IllegalStateException

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

writeInt

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

Throws:: BufferOverflowException; IllegalStateException

rawWriteInt

default S rawWriteInt(int i)
               throws BufferOverflowException,
                      IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeIntAdv

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

Throws:: BufferOverflowException; IllegalStateException

writeUnsignedInt

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

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

writeLong

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

Write a long

Throws:: BufferOverflowException; IllegalStateException

rawWriteLong

default S rawWriteLong(long i)
                throws BufferOverflowException,
                       IllegalStateException

Write a long without a bounds check

Throws:: BufferOverflowException; IllegalStateException

writeLongAdv

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

Throws:: BufferOverflowException; IllegalStateException

writeFloat

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

Throws:: BufferOverflowException; IllegalStateException

writeDouble

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

Throws:: BufferOverflowException; IllegalStateException

writeDoubleAndInt

@NotNull
S writeDoubleAndInt(double d,
                             int i)
                      throws BufferOverflowException,
                             IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

write

@NotNull
default S write(@NotNull
                         @NotNull RandomDataInput bytes)
                  throws BufferOverflowException,
                         IllegalStateException

Write all data or fail.

Throws:: BufferOverflowException; IllegalStateException

write
```
default S write(@NotNull
                @NotNull BytesStore bytes)
         throws BufferOverflowException,
                IllegalStateException
```
Writes all the the passed BytesStore or it fails. If you want to read only as much as there is use read

Parameters:

bytes - to write

Returns:

this

Throws:

BufferOverflowException

IllegalStateException

See Also:

StreamingDataInput.read(Bytes)

realCapacity
```
long realCapacity()
```
Returns:

capacity without resize or -1 if closed

canWriteDirect

default boolean canWriteDirect(long count)

writeSome

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

Throws:: IllegalStateException

write

@NotNull
default S write(@NotNull
                         @NotNull RandomDataInput bytes,
                         long offset,
                         long length)
                  throws BufferOverflowException,
                         BufferUnderflowException,
                         IllegalStateException,
                         IllegalArgumentException

Write all data or fail.

Throws:: BufferOverflowException; BufferUnderflowException; IllegalStateException; IllegalArgumentException

write

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

Write all data or fail.

Throws:: BufferOverflowException; BufferUnderflowException; IllegalStateException; IllegalArgumentException

write

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

Throws:: BufferOverflowException; IllegalStateException

write

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

Write all data or fail.

Throws:: BufferOverflowException; IllegalStateException; IllegalArgumentException; ArrayIndexOutOfBoundsException

unsafeWriteObject

default S unsafeWriteObject(Object o,
                            int length)
                     throws BufferOverflowException,
                            IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

unsafeWriteObject

default S unsafeWriteObject(Object o,
                            int offset,
                            int length)
                     throws BufferOverflowException,
                            IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

unsafeWrite

default S unsafeWrite(long address,
                      int length)

Write raw native memory for a ifixed length

Returns:: this

writeSome

@NotNull
S writeSome(ByteBuffer buffer)
              throws BufferOverflowException,
                     IllegalStateException,
                     BufferUnderflowException

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException

writeBoolean

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

Throws:: BufferOverflowException; IllegalStateException

writeOrderedInt

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

Throws:: BufferOverflowException; IllegalStateException

writeOrderedLong

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

Throws:: BufferOverflowException; IllegalStateException

writeEnum

default <E extends Enum<E>> S writeEnum(@NotNull
                                        E e)
                                 throws BufferOverflowException,
                                        ArithmeticException,
                                        IllegalStateException

Throws:: BufferOverflowException; ArithmeticException; IllegalStateException

appendUtf8

@NotNull
default S appendUtf8(@NotNull
                              @NotNull CharSequence cs)
                       throws BufferOverflowException,
                              IllegalStateException,
                              BufferUnderflowException

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException

appendUtf8

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

Throws:: BufferOverflowException; IllegalStateException

appendUtf8

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

Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException; IllegalArgumentException

appendUtf8

@NotNull
default S appendUtf8(@NotNull
                              @NotNull CharSequence cs,
                              int offset,
                              int length)
                       throws BufferOverflowException,
                              IndexOutOfBoundsException,
                              IllegalStateException,
                              BufferUnderflowException

Throws:: BufferOverflowException; IndexOutOfBoundsException; IllegalStateException; BufferUnderflowException

appendUtf8

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

Throws:: BufferOverflowException; IllegalStateException

appendUtf8

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

Throws:: BufferOverflowException; IllegalStateException

copyFrom

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

Throws:: IOException; BufferOverflowException; IllegalStateException

writePositionRemaining

default void writePositionRemaining(long position,
                                    long length)
                             throws BufferOverflowException

Throws:: BufferOverflowException

writeHistogram

default void writeHistogram(@NotNull
                            @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                     throws BufferOverflowException,
                            IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeBigDecimal

default void writeBigDecimal(@NotNull
                             @NotNull BigDecimal bd)
                      throws BufferOverflowException,
                             IllegalStateException,
                             IllegalArgumentException

Throws:: BufferOverflowException; IllegalStateException; IllegalArgumentException

writeBigInteger

default void writeBigInteger(@NotNull
                             @NotNull BigInteger bi)
                      throws BufferOverflowException,
                             IllegalStateException,
                             IllegalArgumentException

Throws:: BufferOverflowException; IllegalStateException; IllegalArgumentException

writeWithLength

default void writeWithLength(RandomDataInput bytes)
                      throws BufferOverflowException,
                             IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

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 write position must be readPosition() <= writePosition() && writePosition() <= writeLimit()

Returns:

position to write to.

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

How many more bytes can we read.

realReadRemaining
```
default long realReadRemaining()
```
Returns:

how much can be safely read directly.

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

How many more bytes can we written.

realWriteRemaining
```
default long realWriteRemaining()
```
Returns:

writeRemaining with resize

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,
                    IllegalStateException
```
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()

IllegalStateException

addressForRead

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

Throws:: UnsupportedOperationException; BufferUnderflowException; IllegalStateException

addressForWrite
```
long addressForWrite(long offset)
              throws UnsupportedOperationException,
                     BufferOverflowException,
                     IllegalStateException
```
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()

IllegalStateException

addressForWritePosition

long addressForWritePosition()
                      throws UnsupportedOperationException,
                             BufferOverflowException,
                             IllegalStateException

Throws:: UnsupportedOperationException; BufferOverflowException; IllegalStateException

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

bytesForRead

@NotNull
@NotNull Bytes bytesForRead()
                              throws IllegalStateException

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

bytesForWrite

@NotNull
@NotNull Bytes bytesForWrite()
                               throws IllegalStateException

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

compareAndSwapInt

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

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; IllegalStateException

testAndSetInt

void testAndSetInt(long offset,
                   int expected,
                   int value)
            throws BufferOverflowException,
                   IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

compareAndSwapLong

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

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; IllegalStateException

compareAndSwapFloat

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

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; IllegalStateException

compareAndSwapDouble

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

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; IllegalStateException

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

true if these Bytes use shared memory.

isDirectMemory
```
boolean isDirectMemory()
```

Interface StreamingDataOutput<S extends StreamingDataOutput<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

Field Detail

JAVA9_STRING_CODER_LATIN

JAVA9_STRING_CODER_UTF16

Method Detail

writePosition

writeLimit

writeSkip

alignBy

writePositionForHeader

outputStream

writeStopBit

writeStopBit

writeStopBit

writeStopBitDecimal

writeUtf8

writeUtf8

writeUTFΔ

write8bit

write8bit

write8bit

write

write

write8bit

write8bit

writeByte

rawWriteByte

writeUnsignedByte

writeChar

writeShort

writeUnsignedShort

writeInt24

writeUnsignedInt24

writeInt

rawWriteInt

writeIntAdv

writeUnsignedInt

writeLong

rawWriteLong

writeLongAdv

writeFloat

writeDouble

writeDoubleAndInt

write

write

realCapacity

canWriteDirect

writeSome

write

write

write

write

unsafeWriteObject

unsafeWriteObject

unsafeWrite

writeSome

writeBoolean

writeOrderedInt

writeOrderedLong

writeEnum

appendUtf8

appendUtf8

appendUtf8

appendUtf8

appendUtf8

appendUtf8

copyFrom

writePositionRemaining

writeHistogram

writeBigDecimal

writeBigInteger

writeWithLength

start

capacity