RandomDataOutput (OpenHFT/Chronicle-Bytes 2.22ea11 API)

All Known Subinterfaces:

Bytes<Underlying>, BytesStore<B,Underlying>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, ChunkedMappedBytes, CommonMappedBytes, EnbeddedBytes, GuardedNativeBytes, HeapBytesStore, HexDumpBytes, MappedBytes, MappedBytesStore, NativeBytes, NativeBytes.NativeSubBytes, NativeBytesStore, NoBytesStore, OnHeapBytes, PointerBytesStore, SingleMappedBytes, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes
```
public interface RandomDataOutput<R extends RandomDataOutput<R>>
```

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

Method Summary

All Methods Instance Methods Abstract Methods Default 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 R`	`append(long offset, double value, int decimalPlaces, int digits)`
`default R`	`append(long offset, long value, int digits)`
`default ByteOrder`	`byteOrder()`
`@NotNull Bytes`	`bytesForRead()`
`@NotNull 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.
`boolean`	`isDirectMemory()`
`void`	`nativeWrite(long address, long position, long size)` expert level method to copy data from native memory into the BytesStore
`default long`	`readLimit()`
`default long`	`readPosition()` The read position must be `start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()`
`default long`	`readRemaining()`
`default long`	`realCapacity()`
`default long`	`realReadRemaining()`
`default long`	`realWriteRemaining()`
`boolean`	`sharedMemory()`
`default long`	`start()`
`void`	`testAndSetInt(long offset, int expected, int value)`
`default R`	`write(long offsetInRDO, @NotNull byte[] bytes)` Copies whole byte[] into this.
`R`	`write(long writeOffset, byte[] bytes, int readOffset, int length)` Copy from byte[] into this.
`void`	`write(long writeOffset, ByteBuffer bytes, int readOffset, int length)` Copy from ByteBuffer into this.
`default R`	`write(long offsetInRDO, @NotNull BytesStore bytes)` Copies whole BytesStore into this - see `write(long, RandomDataInput, long, long)`
`R`	`write(long writeOffset, RandomDataInput bytes, long readOffset, long length)` Copy from RandomDataInput into this.
`long`	`write8bit(long position, BytesStore bs)` Write the stop bit length and copy the BytesStore
`long`	`write8bit(long position, String s, int start, int length)`
`default R`	`writeBoolean(long offset, boolean flag)` Write a boolean at an offset.
`R`	`writeByte(long offset, byte i8)` Write an unsigned byte at an offset.
`default R`	`writeByte(long offset, int i)` Write a byte at an offset.
`R`	`writeDouble(long offset, double d)` Write a double at an offset.
`R`	`writeFloat(long offset, float d)` Write a float at an offset.
`R`	`writeInt(long offset, int i)` Write an int at an offset.
`default R`	`writeInt24(long offset, int i)`
`default long`	`writeLimit()`
`R`	`writeLong(long offset, long i)` Write a long at an offset.
`default R`	`writeOrderedDouble(long offset, double d)` Perform a non stalling write with a store barrier.
`default R`	`writeOrderedFloat(long offset, float f)` Perform a non stalling write with a store barrier.
`R`	`writeOrderedInt(long offset, int i)` Perform a non stalling write with a store barrier.
`R`	`writeOrderedLong(long offset, long i)` Perform a non stalling write with a store barrier.
`default long`	`writePosition()` The write position must be `readPosition() <= writePosition() && writePosition() <= writeLimit()`
`default long`	`writeRemaining()`
`R`	`writeShort(long offset, short i)` Write a short at an offset.
`default R`	`writeUnsignedByte(long offset, int i)` Write an unsigned byte at an offset.
`default R`	`writeUnsignedInt(long offset, long i)` Write an unsigned byte at an offset.
`default R`	`writeUnsignedShort(long offset, int i)` Write an unsigned byte at an offset.
`default long`	`writeUtf8(long offset, @Nullable CharSequence cs)` Writes the given `cs` to this `RandomDataOutput` from the given `offset`, in Utf8 format.
`default long`	`writeUtf8Limited(long offset, @Nullable CharSequence cs, int maxUtf8Len)` Writes the given `cs` to this `RandomDataOutput` from the given `offset`, in Utf8 format, checking that the utf8 encoding size of the given char sequence is less or equal to the given `maxUtf8Len`, otherwise `IllegalArgumentException` is thrown, and no bytes of this `RandomDataOutput` are overwritten.
`R`	`writeVolatileByte(long offset, byte i8)`
`default R`	`writeVolatileDouble(long offset, double d)`
`default R`	`writeVolatileFloat(long offset, float f)`
`R`	`writeVolatileInt(long offset, int i32)`
`R`	`writeVolatileLong(long offset, long i64)`
`R`	`writeVolatileShort(long offset, short i16)`
`R`	`zeroOut(long start, long end)` Zero out the bytes between the start and the end.

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

Method Detail

writeByte

@NotNull
default R writeByte(long offset,
                             int i)
                      throws BufferOverflowException,
                             IllegalArgumentException,
                             ArithmeticException,
                             IllegalStateException

Write a byte at an offset.

Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalArgumentException - if the value cannot be cast to the type without loss.; ArithmeticException; IllegalStateException

writeUnsignedByte

@NotNull
default R writeUnsignedByte(long offset,
                                     int i)
                              throws BufferOverflowException,
                                     IllegalArgumentException,
                                     ArithmeticException,
                                     IllegalStateException

Write an unsigned byte at an offset.

Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalArgumentException - if the value cannot be cast to the type without loss.; ArithmeticException; IllegalStateException

writeBoolean

@NotNull
default R writeBoolean(long offset,
                                boolean flag)
                         throws BufferOverflowException,
                                IllegalStateException

Write a boolean at an offset.

Parameters:: offset - to write to; flag - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeUnsignedShort

@NotNull
default R writeUnsignedShort(long offset,
                                      int i)
                               throws BufferOverflowException,
                                      ArithmeticException,
                                      IllegalStateException

Write an unsigned byte at an offset.

Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; ArithmeticException - if the value cannot be cast to the type without loss.; IllegalStateException

writeUnsignedInt

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

Write an unsigned byte at an offset.

Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; ArithmeticException - if the value cannot be cast to the type without loss.; IllegalStateException

writeByte

@NotNull
R writeByte(long offset,
                     byte i8)
              throws BufferOverflowException,
                     IllegalStateException

Write an unsigned byte at an offset.

Parameters:: offset - to write to; i8 - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeShort

@NotNull
R writeShort(long offset,
                      short i)
               throws BufferOverflowException,
                      IllegalStateException

Write a short at an offset.

Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeInt24

@NotNull
default R writeInt24(long offset,
                              int i)
                       throws BufferOverflowException,
                              IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeInt

@NotNull
R writeInt(long offset,
                    int i)
             throws BufferOverflowException,
                    IllegalStateException

Write an int at an offset.

Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeOrderedInt

@NotNull
R writeOrderedInt(long offset,
                           int i)
                    throws BufferOverflowException,
                           IllegalStateException

Perform a non stalling write with a store barrier.

Parameters:: offset - to write to; i - value to write
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeOrderedFloat

@NotNull
default R writeOrderedFloat(long offset,
                                     float f)
                              throws BufferOverflowException,
                                     IllegalStateException

Perform a non stalling write with a store barrier.

Parameters:: offset - to write to; f - value to write
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeLong

@NotNull
R writeLong(long offset,
                     long i)
              throws BufferOverflowException,
                     IllegalStateException

Write a long at an offset.

Parameters:: offset - to write to; i - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeOrderedLong

@NotNull
R writeOrderedLong(long offset,
                            long i)
                     throws BufferOverflowException,
                            IllegalStateException

Perform a non stalling write with a store barrier.

Parameters:: offset - to write to; i - value to write
Returns:: this
Throws:: BufferOverflowException; IllegalStateException

writeOrderedDouble

@NotNull
default R writeOrderedDouble(long offset,
                                      double d)
                               throws BufferOverflowException,
                                      IllegalStateException

Perform a non stalling write with a store barrier.

Parameters:: offset - to write to; d - value to write
Returns:: this
Throws:: BufferOverflowException; IllegalStateException

writeFloat

@NotNull
R writeFloat(long offset,
                      float d)
               throws BufferOverflowException,
                      IllegalStateException

Write a float at an offset.

Parameters:: offset - to write to; d - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeDouble

@NotNull
R writeDouble(long offset,
                       double d)
                throws BufferOverflowException,
                       IllegalStateException

Write a double at an offset.

Parameters:: offset - to write to; d - the value
Returns:: this
Throws:: BufferOverflowException - if the capacity was exceeded; IllegalStateException

writeVolatileByte

@NotNull
R writeVolatileByte(long offset,
                             byte i8)
                      throws BufferOverflowException,
                             IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeVolatileShort

@NotNull
R writeVolatileShort(long offset,
                              short i16)
                       throws BufferOverflowException,
                              IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeVolatileInt

@NotNull
R writeVolatileInt(long offset,
                            int i32)
                     throws BufferOverflowException,
                            IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeVolatileLong

@NotNull
R writeVolatileLong(long offset,
                             long i64)
                      throws BufferOverflowException,
                             IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeVolatileFloat

@NotNull
default R writeVolatileFloat(long offset,
                                      float f)
                               throws BufferOverflowException,
                                      IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

writeVolatileDouble

@NotNull
default R writeVolatileDouble(long offset,
                                       double d)
                                throws BufferOverflowException,
                                       IllegalStateException

Throws:: BufferOverflowException; IllegalStateException

write

@NotNull
default R write(long offsetInRDO,
                         @NotNull
                         @NotNull byte[] bytes)
                  throws BufferOverflowException,
                         IllegalStateException

Copies whole byte[] into this. See write(long, byte[], int, int)

Throws:: BufferOverflowException; IllegalStateException

write
```
@NotNull
R write(long writeOffset,
                 byte[] bytes,
                 int readOffset,
                 int length)
          throws BufferOverflowException,
                 IllegalStateException
```
Copy from byte[] into this.
Does not update cursors e.g. writePosition()

Parameters:

writeOffset - offset to write to

bytes - copy from bytes

readOffset - copy from offset

length -

Returns:

this

Throws:

BufferOverflowException

IllegalStateException

write
```
void write(long writeOffset,
           ByteBuffer bytes,
           int readOffset,
           int length)
    throws BufferOverflowException,
           IllegalStateException
```
Copy from ByteBuffer into this.
Does not update cursors e.g. writePosition()

Parameters:

writeOffset - offset to write to

bytes - copy from bytes

readOffset - copy from offset

length -

Throws:

BufferOverflowException

IllegalStateException

write

@NotNull
default R write(long offsetInRDO,
                         @NotNull
                         @NotNull BytesStore bytes)
                  throws BufferOverflowException,
                         IllegalStateException

Copies whole BytesStore into this - see write(long, RandomDataInput, long, long)

Throws:: BufferOverflowException; IllegalStateException

write

@NotNull
R write(long writeOffset,
                 RandomDataInput bytes,
                 long readOffset,
                 long length)
          throws BufferOverflowException,
                 BufferUnderflowException,
                 IllegalStateException

Copy from RandomDataInput into this. Does not bump writePosition() nor RandomCommon.readPosition()

Parameters:: writeOffset - offset to write to; bytes - copy from bytes; readOffset - copy from offset; length -
Returns:: this
Throws:: BufferOverflowException; IllegalStateException; BufferUnderflowException

zeroOut
```
@NotNull
R zeroOut(long start,
                   long end)
            throws IllegalStateException
```
Zero out the bytes between the start and the end.

Parameters:

start - index of first byte inclusive

end - index of last byte exclusive

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

IllegalStateException

append

@NotNull
default R append(long offset,
                          long value,
                          int digits)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          IllegalStateException

Throws:: BufferOverflowException; IllegalArgumentException; IllegalStateException

append

@NotNull
default R append(long offset,
                          double value,
                          int decimalPlaces,
                          int digits)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          IllegalStateException,
                          ArithmeticException

Throws:: BufferOverflowException; IllegalArgumentException; IllegalStateException; ArithmeticException

nativeWrite
```
void nativeWrite(long address,
                 long position,
                 long size)
          throws BufferOverflowException,
                 IllegalStateException
```
expert level method to copy data from native memory into the BytesStore

Parameters:

address - in native memory to copy from

position - in BytesStore to copy to

size - in bytes

Throws:

BufferOverflowException

IllegalStateException

writeUtf8
```
default long writeUtf8(long offset,
                       @Nullable
                       @Nullable CharSequence cs)
                throws BufferOverflowException,
                       IllegalStateException,
                       ArithmeticException
```
Writes the given cs to this RandomDataOutput from the given offset, in Utf8 format. Returns the offset after the written char sequence.

Parameters:

offset - the offset to write char sequence from

cs - the char sequence to write, could be null

Returns:

the offset after the char sequence written, in this RandomDataOutput

Throws:

BufferOverflowException

IllegalStateException

ArithmeticException

See Also:

RandomDataInput.readUtf8(long, Appendable)

writeUtf8Limited
```
default long writeUtf8Limited(long offset,
                              @Nullable
                              @Nullable CharSequence cs,
                              int maxUtf8Len)
                       throws BufferOverflowException,
                              IllegalStateException,
                              ArithmeticException
```
Writes the given cs to this RandomDataOutput from the given offset, in Utf8 format, checking that the utf8 encoding size of the given char sequence is less or equal to the given maxUtf8Len, otherwise IllegalArgumentException is thrown, and no bytes of this RandomDataOutput are overwritten. Returns the offset after the written char sequence.

Parameters:

offset - the offset to write char sequence from

cs - the char sequence to write, could be null

maxUtf8Len - the maximum allowed length (in Utf8 encoding) of the given char sequence

Returns:

the offset after the char sequence written, in this RandomDataOutput

Throws:

IllegalArgumentException - if the given char sequence size in Utf8 encoding exceeds maxUtf8Len

BufferOverflowException

IllegalStateException

ArithmeticException

See Also:

RandomDataInput.readUtf8Limited(long, Appendable, int), RandomDataInput.readUtf8Limited(long, int)

write8bit
```
long write8bit(long position,
               BytesStore bs)
```
Write the stop bit length and copy the BytesStore

Parameters:

position - to write

bs - to copy.

Returns:

the offset after the char sequence written, in this RandomDataOutput

write8bit

long write8bit(long position,
               String s,
               int start,
               int length)

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()
```
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 RandomDataOutput<R extends RandomDataOutput<R>>

Field Summary

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

Method Summary

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

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

Method Detail

writeByte

writeUnsignedByte

writeBoolean

writeUnsignedShort

writeUnsignedInt

writeByte

writeShort

writeInt24

writeInt

writeOrderedInt

writeOrderedFloat

writeLong

writeOrderedLong

writeOrderedDouble

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

writeVolatileFloat

writeVolatileDouble

write

write

write

write

write

zeroOut

append

append

nativeWrite

writeUtf8

writeUtf8Limited

write8bit

write8bit

start

capacity

realCapacity

readPosition

writePosition

readRemaining

realReadRemaining

writeRemaining

realWriteRemaining

readLimit

writeLimit

addressForRead

addressForRead

addressForWrite

addressForWritePosition

byteOrder

bytesForRead

bytesForWrite

compareAndSwapInt

testAndSetInt

compareAndSwapLong

compareAndSwapFloat

compareAndSwapDouble

sharedMemory

isDirectMemory