net.openhft.chronicle.bytes

Interface RandomDataOutput<R extends RandomDataOutput<R>>

All Known Subinterfaces:

Bytes<Underlying>, BytesStore<B,Underlying>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, GuardedNativeBytes, HeapBytesStore, HexDumpBytes, MappedBytes, MappedBytesStore, NativeBytes, NativeBytes.NativeSubBytes, NativeBytesStore, NoBytesStore, OnHeapBytes, PointerBytesStore, ReadOnlyMappedBytesStore, ReleasedBytesStore, 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

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()
boolean	sharedMemory()
default long	start()
void	testAndSetInt(long offset, int expected, int value)
default R	write(long offsetInRDO, @NotNull byte[] bytes)
R	write(long offsetInRDO, byte[] bytes, int offset, int length)
void	write(long offsetInRDO, ByteBuffer bytes, int offset, int length)
default R	write(long offsetInRDO, @NotNull BytesStore bytes)
R	write(long writeOffset, RandomDataInput bytes, long readOffset, long 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 read 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

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.

writeUnsignedByte

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

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.

writeBoolean

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

Write a boolean at an offset.

Parameters:

offset - to write to

flag - the value

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

writeUnsignedShort

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

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.

writeUnsignedInt

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

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.

writeByte

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

Write an unsigned byte at an offset.

Parameters:

offset - to write to

i8 - the value

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

writeShort

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

Write a short at an offset.

Parameters:

offset - to write to

i - the value

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

writeInt24

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

Throws:

BufferOverflowException

writeInt

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

Write an int at an offset.

Parameters:

offset - to write to

i - the value

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

writeOrderedInt

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

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

writeOrderedFloat

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

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

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

Perform a non stalling write with a store barrier.

Parameters:

offset - to write to

i - value to write

Returns:

this

Throws:

BufferOverflowException

writeOrderedDouble

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

Perform a non stalling write with a store barrier.

Parameters:

offset - to write to

d - value to write

Returns:

this

Throws:

BufferOverflowException

writeFloat

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

Write a float at an offset.

Parameters:

offset - to write to

d - the value

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

writeDouble

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

Write a double at an offset.

Parameters:

offset - to write to

d - the value

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

writeVolatileByte

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

Throws:

BufferOverflowException

writeVolatileShort

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

Throws:

BufferOverflowException

writeVolatileInt

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

Throws:

BufferOverflowException

writeVolatileLong

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

Throws:

BufferOverflowException

writeVolatileFloat

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

Throws:

BufferOverflowException

writeVolatileDouble

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

Throws:

BufferOverflowException

write

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

Throws:

BufferOverflowException

write

@NotNull
R write(long offsetInRDO,
                 byte[] bytes,
                 int offset,
                 int length)
          throws BufferOverflowException

Throws:

BufferOverflowException

write

void write(long offsetInRDO,
           ByteBuffer bytes,
           int offset,
           int length)
    throws BufferOverflowException

Throws:

BufferOverflowException

write

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

Throws:

BufferOverflowException

write

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

Throws:

BufferOverflowException

BufferUnderflowException

zeroOut

@NotNull
R zeroOut(long start,
                   long end)

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

append

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

Throws:

BufferOverflowException

append

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

Throws:

BufferOverflowException

nativeWrite

void nativeWrite(long address,
                 long position,
                 long size)
          throws BufferOverflowException

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

writeUtf8

default long writeUtf8(long offset,
                       @Nullable
                       @Nullable CharSequence cs)
                throws BufferOverflowException

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

See Also:

RandomDataInput.readUtf8(long, Appendable)

writeUtf8Limited

default long writeUtf8Limited(long offset,
                              @Nullable
                              @Nullable CharSequence cs,
                              int maxUtf8Len)
                       throws BufferOverflowException

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

See Also:

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

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 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()

addressForRead

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

Throws:

UnsupportedOperationException

BufferUnderflowException

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()

addressForWritePosition

long addressForWritePosition()
                      throws UnsupportedOperationException,
                             BufferOverflowException

Throws:

UnsupportedOperationException

BufferOverflowException

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

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

testAndSetInt

void testAndSetInt(long offset,
                   int expected,
                   int value)

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()