net.openhft.chronicle.bytes

Interface RandomDataOutput<R extends RandomDataOutput<R>>

All Known Subinterfaces:

Bytes<Underlying>, BytesStore<B,Underlying>

All Known Implementing Classes:

AbstractBytes, AbstractBytesStore, HeapBytesStore, MappedBytes, MappedBytesStore, NativeBytes, NativeBytesStore, NoBytesStore, PointerBytesStore, ReadOnlyMappedBytesStore, UncheckedBytes, UncheckedNativeBytes, VanillaBytes

public interface RandomDataOutput<R extends RandomDataOutput<R>>

Method Summary

Modifier and Type	Method and Description
long	address(long offset) Obtain the underlying address.
default R	append(long offset, double value, int decimalPlaces, int digits)
default R	append(long offset, long value, int digits)
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.
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()
boolean	sharedMemory()
default long	start()
default R	write(long offsetInRDO, 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, BytesStore bytes)
R	write(long offsetInRDO, RandomDataInput bytes, long offset, 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, CharSequence cs) Writes the given cs to this RandomDataOutput from the given offset, in Utf8 format.
default long	writeUtf8Limited(long offset, 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.ReferenceCounted

refCount, release, release, releaseAll, reserve, tryReserve

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

Write a long at an offset.

Parameters:

offset - to write to

i - the value

Returns:

this

Throws:

BufferOverflowException - if the capacity was exceeded

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

R writeVolatileByte(long offset,
                    byte i8)
             throws BufferOverflowException

Throws:

BufferOverflowException

writeVolatileShort

R writeVolatileShort(long offset,
                     short i16)
              throws BufferOverflowException

Throws:

BufferOverflowException

writeVolatileInt

R writeVolatileInt(long offset,
                   int i32)
            throws BufferOverflowException

Throws:

BufferOverflowException

writeVolatileLong

R writeVolatileLong(long offset,
                    long i64)
             throws BufferOverflowException

Throws:

BufferOverflowException

writeVolatileFloat

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

Throws:

BufferOverflowException

writeVolatileDouble

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

Throws:

BufferOverflowException

write

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

Throws:

BufferOverflowException

write

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

Throws:

BufferOverflowException

IllegalArgumentException

write

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

Throws:

BufferOverflowException

IllegalArgumentException

write

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

Throws:

BufferOverflowException

write

@NotNull
R write(long offsetInRDO,
                 RandomDataInput bytes,
                 long offset,
                 long length)
          throws BufferOverflowException,
                 IllegalArgumentException,
                 BufferUnderflowException

Throws:

BufferOverflowException

IllegalArgumentException

BufferUnderflowException

zeroOut

@NotNull
R zeroOut(long start,
                   long end)
            throws IllegalArgumentException

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

IllegalArgumentException

append

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

Throws:

BufferOverflowException

IllegalArgumentException

append

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

Throws:

BufferOverflowException

IllegalArgumentException

nativeWrite

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

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

writeUtf8

default long writeUtf8(long offset,
                       @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
                              CharSequence cs,
                              int maxUtf8Len)
                       throws BufferOverflowException,
                              IllegalArgumentException

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.

readPosition

default long readPosition()

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

Returns:

position to read from.

writePosition

default long writePosition()

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

Returns:

position to write to.

readRemaining

default long readRemaining()

Returns:

How many more bytes can we read.

writeRemaining

default long writeRemaining()

Returns:

How many more bytes can we written.

readLimit

default long readLimit()

Returns:

the highest offset or position allowed for this buffer.

writeLimit

default long writeLimit()

address

long address(long offset)
      throws UnsupportedOperationException,
             IllegalArgumentException

Obtain the underlying address. This is for expert users only.

Parameters:

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

Returns:

the underlying address of the buffer

Throws:

UnsupportedOperationException - if the underlying buffer is on the heap

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

byteOrder

default ByteOrder byteOrder()

bytesForRead

Bytes bytesForRead()
            throws IllegalStateException

Returns:

the streaming bytes for reading.

Throws:

IllegalStateException

bytesForWrite

Bytes bytesForWrite()
             throws IllegalStateException

Returns:

the streaming bytes for writing.

Throws:

IllegalStateException

compareAndSwapInt

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

Perform a 32-bit CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

IllegalArgumentException

compareAndSwapLong

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

Perform a 64-bit CAS at a given offset.

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

IllegalArgumentException

compareAndSwapFloat

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

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

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

IllegalArgumentException

compareAndSwapDouble

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

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

Parameters:

offset - to perform CAS

expected - value

value - to set

Returns:

true, if successful.

Throws:

BufferOverflowException

IllegalArgumentException

sharedMemory

boolean sharedMemory()

Returns:

true if these Bytes use shared memory.

isDirectMemory

boolean isDirectMemory()