net.openhft.chronicle.bytes

Interface RandomDataOutput<R extends RandomDataOutput<R>>

All Superinterfaces:

RandomCommon, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceOwner

All Known Subinterfaces:

Bytes<U>, BytesStore<B,U>

All Known Implementing Classes:

AbstractBytes, net.openhft.chronicle.bytes.internal.AbstractBytesStore, GuardedNativeBytes, HexDumpBytes, MappedBytes, MappedBytesStore, NativeBytes, net.openhft.chronicle.bytes.internal.NativeBytesStore, OnHeapBytes, PointerBytesStore, SubBytes, UncheckedBytes, UncheckedNativeBytes, VanillaBytes

public interface RandomDataOutput<R extends RandomDataOutput<R>>
extends RandomCommon

Provides methods for writing data to a byte sequence or buffer at arbitrary offsets. Implementations extend RandomCommon. Use atomic or ordered methods for thread safety.

See Also:

RandomDataInput

Field Summary

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

INIT, TMP

Method Summary

Modifier and Type	Method and Description
double	addAndGetDouble(long offset, double adding) Atomically adds a 64-bit double value to the current value at the specified offset and returns the resulting sum.
float	addAndGetFloat(long offset, float adding) Atomically adds a 32-bit float value to the current value at the specified offset and returns the resulting sum.
int	addAndGetInt(long offset, int adding) Atomically adds a 32-bit integer value to the current value at the specified offset and returns the resulting sum.
long	addAndGetLong(long offset, long adding) Atomically adds a 64-bit long value to the current value at the specified offset and returns the resulting sum.
default R	append(long offset, double value, int decimalPlaces, int digits) Appends a double value as a string with a specified number of decimal places and total digits at the given offset.
default R	append(long offset, long value, int digits) Appends a long value as a string with a specified number of digits at the given offset.
default long	appendAndReturnLength(long writePosition, boolean negative, long mantissa, int exponent, boolean append0)
boolean	compareAndSwapDouble(long offset, double expected, double value) Performs a compare-and-swap (CAS) operation for a 64-bit double at the given offset.
boolean	compareAndSwapFloat(long offset, float expected, float value) Performs a compare-and-swap (CAS) operation for a 32-bit float at the given offset.
boolean	compareAndSwapInt(long offset, int expected, int value) Performs a 32-bit compare-and-swap (CAS) operation at a given offset.
boolean	compareAndSwapLong(long offset, long expected, long value) Performs a 64-bit compare-and-swap (CAS) operation at a given offset.
void	nativeWrite(long address, long position, long size) Expert-level method that copies data directly from native memory into this BytesStore.
void	testAndSetInt(long offset, int expected, int value) Tests if the current value at the specified offset equals the expected value and, if so, sets it to the provided value.
default R	write(long offsetInRDO, byte[] bytes) Copies the entire byte array into this data output.
R	write(long writeOffset, byte[] byteArray, int readOffset, int length) Copies the provided byteArray to this Bytes object starting at writeOffset taking content starting at readOffset but copying at most length bytes.
void	write(long writeOffset, @NotNull ByteBuffer bytes, int readOffset, int length) Copies a segment from the provided ByteBuffer into this data output.
default R	write(long offsetInRDO, @NotNull BytesStore<?,?> bytes) Copies the entire content of the provided BytesStore into this data output.
R	write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length) Copies a segment from the provided RandomDataInput into this data output.
long	write8bit(long position, @NotNull BytesStore<?,?> bs) Writes a BytesStore instance to this RandomDataOutput at the given position.
long	write8bit(long position, @NotNull String s, int start, int length) Writes a portion of a string to this RandomDataOutput at the given position.
default R	writeBoolean(long offset, boolean flag) Writes a boolean value at the specified offset.
R	writeByte(long offset, byte i8) Writes a byte at the specified non-negative offset.
default R	writeByte(long offset, int i) Writes a byte value at the specified offset.
R	writeDouble(long offset, double d) Writes a double-precision floating-point value at the specified non-negative offset.
R	writeFloat(long offset, float d) Writes a single-precision floating-point value at the specified non-negative offset.
R	writeInt(long offset, int i) Writes an integer value at the specified non-negative offset.
default R	writeInt24(long offset, int i) Writes a 24-bit integer at the specified non-negative offset.
R	writeLong(long offset, long i) Writes a long integer value at the specified non-negative offset.
default R	writeOrderedDouble(long offset, double d) Performs a non-blocking write operation with a memory barrier to ensure order of stores.
default R	writeOrderedFloat(long offset, float f) Performs a non-blocking write operation with a memory barrier to ensure order of stores.
R	writeOrderedInt(long offset, int i) Performs a non-blocking write operation with a memory barrier to ensure order of stores.
R	writeOrderedLong(long offset, long i) Performs a non-blocking write operation with a memory barrier to ensure order of stores.
R	writeShort(long offset, short i) Writes a short integer at the specified non-negative offset.
default R	writeUnsignedByte(long offset, int i) Writes an unsigned byte value at the specified offset.
default R	writeUnsignedInt(long offset, long i) Writes an unsigned integer value at the specified offset.
default R	writeUnsignedShort(long offset, int i) Writes an unsigned short value at the specified offset.
default long	writeUtf8(long writeOffset, @Nullable CharSequence text) Writes the provided text into this RandomDataOutput writing at the given writeOffset, in Utf8 format.
default long	writeUtf8Limited(long writeOffset, @Nullable CharSequence text, int maxUtf8Len) Writes the given text to this RandomDataOutput writing at the provided writeOffset, in Utf8 format, checking that the utf8 encoding size of the given char sequence is less or equal to the provided maxUtf8Len, otherwise IllegalArgumentException is thrown, and no bytes of this RandomDataOutput are overwritten.
R	writeVolatileByte(long offset, byte i8) Writes a volatile byte at the specified non-negative offset.
default R	writeVolatileDouble(long offset, double d) Writes a volatile double-precision floating-point value at the specified non-negative offset.
default R	writeVolatileFloat(long offset, float f) Writes a volatile single-precision floating-point value at the specified non-negative offset.
R	writeVolatileInt(long offset, int i32) Writes a volatile integer at the specified non-negative offset.
R	writeVolatileLong(long offset, long i64) Writes a volatile long integer at the specified non-negative offset.
R	writeVolatileShort(long offset, short i16) Writes a volatile short at the specified non-negative offset.
R	zeroOut(long start, long end) Fills the specified range in this data output with zeroes.

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

addressForRead, addressForRead, addressForWrite, addressForWritePosition, byteOrder, bytesForRead, bytesForWrite, capacity, isDirectMemory, lengthWritten, readLimit, readPosition, readRemaining, realCapacity, realReadRemaining, realWriteRemaining, sharedMemory, start, writeLimit, writePosition, writeRemaining

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

addReferenceChangeListener, refCount, release, releaseLast, releaseLast, removeReferenceChangeListener, reserve, 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,
                             net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a byte value at the specified offset.

Parameters:

offset - The position within the data stream to write the byte to.

i - The byte value to write. Must be within the range of a byte (-128 to 127).

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

IllegalArgumentException - If the provided integer value cannot be safely cast to a byte without loss of information.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeUnsignedByte

@NotNull
default R writeUnsignedByte(long offset,
                                     int i)
                              throws BufferOverflowException,
                                     IllegalArgumentException,
                                     net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes an unsigned byte value at the specified offset.

Parameters:

offset - The position within the data stream to write the unsigned byte to.

i - The unsigned byte value to write. Must be within the range of an unsigned byte (0 to 255).

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

IllegalArgumentException - If the provided integer value cannot be safely cast to an unsigned byte without loss of information.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeBoolean

@NotNull
default R writeBoolean(long offset,
                                boolean flag)
                         throws BufferOverflowException,
                                net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a boolean value at the specified offset.

Parameters:

offset - The position within the data stream to write the boolean value to.

flag - The boolean value to write. Translates 'true' as 'Y' and 'false' as 'N'.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeUnsignedShort

@NotNull
default R writeUnsignedShort(long offset,
                                      int i)
                               throws BufferOverflowException,
                                      ArithmeticException,
                                      net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes an unsigned short value at the specified offset.

Parameters:

offset - The position within the data stream to write the unsigned short to.

i - The unsigned short value to write. Must be within the range of an unsigned short (0 to 65535).

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

ArithmeticException - If the provided integer value cannot be safely cast to an unsigned short without loss of information.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeUnsignedInt

@NotNull
default R writeUnsignedInt(long offset,
                                    long i)
                             throws BufferOverflowException,
                                    ArithmeticException,
                                    net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes an unsigned integer value at the specified offset.

Parameters:

offset - The position within the data stream to write the unsigned integer to.

i - The unsigned integer value to write. Must be within the range of an unsigned integer (0 to 4294967295).

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

ArithmeticException - If the provided long value cannot be safely cast to an unsigned integer without loss of information.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeByte

@NotNull
R writeByte(long offset,
                     byte i8)
              throws BufferOverflowException,
                     net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a byte at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the byte to.

i8 - The byte value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeShort

@NotNull
R writeShort(long offset,
                      short i)
               throws BufferOverflowException,
                      net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a short integer at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the short integer to.

i - The short integer value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeInt24

@NotNull
default R writeInt24(long offset,
                              int i)
                       throws BufferOverflowException,
                              net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a 24-bit integer at the specified non-negative offset. This method writes the lower 16 bits and then the upper 8 bits of the integer in two steps.

Parameters:

offset - The non-negative position within the data stream to write the 24-bit integer to.

i - The integer value to write. Only the lowest 24 bits are used.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset plus two exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeInt

@NotNull
R writeInt(long offset,
                    int i)
             throws BufferOverflowException,
                    net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes an integer value at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the integer to.

i - The integer value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeOrderedInt

@NotNull
R writeOrderedInt(long offset,
                           int i)
                    throws BufferOverflowException,
                           net.openhft.chronicle.core.io.ClosedIllegalStateException

Performs a non-blocking write operation with a memory barrier to ensure order of stores. Writes an integer at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the integer to.

i - The integer value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeOrderedFloat

@NotNull
default R writeOrderedFloat(long offset,
                                     float f)
                              throws BufferOverflowException,
                                     net.openhft.chronicle.core.io.ClosedIllegalStateException

Performs a non-blocking write operation with a memory barrier to ensure order of stores. Writes a floating-point number at the specified offset.

Parameters:

offset - The position within the data stream to write the float to.

f - The float value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeLong

@NotNull
R writeLong(long offset,
                     long i)
              throws BufferOverflowException,
                     net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a long integer value at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the long integer to.

i - The long integer value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeOrderedLong

@NotNull
R writeOrderedLong(long offset,
                            long i)
                     throws BufferOverflowException,
                            net.openhft.chronicle.core.io.ClosedIllegalStateException

Performs a non-blocking write operation with a memory barrier to ensure order of stores. Writes a long integer at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the long integer to.

i - The long integer value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeOrderedDouble

@NotNull
default R writeOrderedDouble(long offset,
                                      double d)
                               throws BufferOverflowException,
                                      net.openhft.chronicle.core.io.ClosedIllegalStateException

Performs a non-blocking write operation with a memory barrier to ensure order of stores. Writes a double-precision floating-point number at the specified offset.

Parameters:

offset - The position within the data stream to write the double to.

d - The double value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeFloat

@NotNull
R writeFloat(long offset,
                      float d)
               throws BufferOverflowException,
                      net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a single-precision floating-point value at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the float to.

d - The float value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeDouble

@NotNull
R writeDouble(long offset,
                       double d)
                throws BufferOverflowException,
                       net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a double-precision floating-point value at the specified non-negative offset.

Parameters:

offset - The non-negative position within the data stream to write the double to.

d - The double value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeVolatileByte

@NotNull
R writeVolatileByte(long offset,
                             byte i8)
                      throws BufferOverflowException,
                             net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a volatile byte at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.

Parameters:

offset - The non-negative position within the data stream to write the byte to.

i8 - The byte value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeVolatileShort

@NotNull
R writeVolatileShort(long offset,
                              short i16)
                       throws BufferOverflowException,
                              net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a volatile short at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.

Parameters:

offset - The non-negative position within the data stream to write the short to.

i16 - The short value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeVolatileInt

@NotNull
R writeVolatileInt(long offset,
                            int i32)
                     throws BufferOverflowException,
                            net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a volatile integer at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.

Parameters:

offset - The non-negative position within the data stream to write the integer to.

i32 - The integer value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeVolatileLong

@NotNull
R writeVolatileLong(long offset,
                             long i64)
                      throws BufferOverflowException,
                             net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a volatile long integer at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.

Parameters:

offset - The non-negative position within the data stream to write the long integer to.

i64 - The long integer value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeVolatileFloat

@NotNull
default R writeVolatileFloat(long offset,
                                      float f)
                               throws BufferOverflowException,
                                      net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a volatile single-precision floating-point value at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.

Parameters:

offset - The non-negative position within the data stream to write the float to.

f - The float value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeVolatileDouble

@NotNull
default R writeVolatileDouble(long offset,
                                       double d)
                                throws BufferOverflowException,
                                       net.openhft.chronicle.core.io.ClosedIllegalStateException

Writes a volatile double-precision floating-point value at the specified non-negative offset. The write is volatile, ensuring it is not cached and instantly visible to all threads.

Parameters:

offset - The non-negative position within the data stream to write the double to.

d - The double value to write.

Returns:

Reference to the current instance, allowing for method chaining.

Throws:

BufferOverflowException - If the specified offset exceeds the available capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

write

@NotNull
default R write(long offsetInRDO,
                         byte[] bytes)
                  throws BufferOverflowException,
                         net.openhft.chronicle.core.io.ClosedIllegalStateException

Copies the entire byte array into this data output. This is a convenience method for write(long, byte[], int, int).

Parameters:

offsetInRDO - the non-negative offset within the data output where the byte array should be written.

bytes - the byte array to be written.

Returns:

a reference to this instance.

Throws:

BufferOverflowException - If the capacity of this data output was exceeded.

NullPointerException - If the provided byte array is null.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

write

@NotNull
R write(long writeOffset,
                 byte[] byteArray,
                 int readOffset,
                 int length)
          throws BufferOverflowException,
                 net.openhft.chronicle.core.io.ClosedIllegalStateException,
                 net.openhft.chronicle.core.io.ThreadingIllegalStateException

Copies the provided byteArray to this Bytes object starting at writeOffset taking content starting at readOffset but copying at most length bytes.

Does not update cursors e.g. RandomCommon.writePosition()

Parameters:

writeOffset - the non-negative offset within the data output where the segment should be written.

byteArray - the byte array containing the segment to be written.

readOffset - the non-negative offset within the byte array where the segment begins.

length - the non-negative length of the segment.

Returns:

a reference to this instance.

Throws:

BufferOverflowException - If the capacity of this data output was exceeded.

IllegalArgumentException - If any of the provided offsets or length are negative.

NullPointerException - If the provided byte array is null.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

write

void write(long writeOffset,
           @NotNull
           @NotNull ByteBuffer bytes,
           int readOffset,
           int length)
    throws BufferOverflowException,
           net.openhft.chronicle.core.io.ClosedIllegalStateException

Copies a segment from the provided ByteBuffer into this data output.

Does not update cursors e.g. RandomCommon.writePosition()

Parameters:

writeOffset - the non-negative offset within the data output where the segment should be written.

bytes - the ByteBuffer containing the segment to be written.

readOffset - the non-negative offset within the ByteBuffer where the segment begins.

length - the non-negative length of the segment.

Throws:

BufferOverflowException - If the capacity of this data output was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

write

@NotNull
default R write(long offsetInRDO,
                         @NotNull
                         @NotNull BytesStore<?,?> bytes)
                  throws BufferOverflowException,
                         net.openhft.chronicle.core.io.ClosedIllegalStateException

Copies the entire content of the provided BytesStore into this data output. This is a convenience method for write(long, RandomDataInput, long, long).

Parameters:

offsetInRDO - the non-negative offset within the data output where the BytesStore content should be written.

bytes - the BytesStore whose content should be written.

Returns:

a reference to this instance.

Throws:

BufferOverflowException - If the capacity of this data output was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

NullPointerException - If the provided BytesStore is null.

write

@NotNull
R write(long writeOffset,
                 @NotNull
                 @NotNull RandomDataInput bytes,
                 long readOffset,
                 long length)
          throws BufferOverflowException,
                 BufferUnderflowException,
                 net.openhft.chronicle.core.io.ClosedIllegalStateException,
                 net.openhft.chronicle.core.io.ThreadingIllegalStateException

Copies a segment from the provided RandomDataInput into this data output. This operation does not update the RandomCommon.writePosition() of this output nor the RandomCommon.readPosition() of the input.

Parameters:

writeOffset - the non-negative offset within this data output where the segment should be written.

bytes - the RandomDataInput source containing the segment to be written.

readOffset - the non-negative offset within the source where the segment begins.

length - the non-negative length of the segment.

Returns:

a reference to this instance.

Throws:

BufferOverflowException - If the capacity of this data output was exceeded.

BufferUnderflowException - If the source does not have enough data to fill the length.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

zeroOut

@NotNull
R zeroOut(long start,
                   long end)
            throws net.openhft.chronicle.core.io.ClosedIllegalStateException

Fills the specified range in this data output with zeroes.

Parameters:

start - the starting index of the range to zero out (inclusive).

end - the ending index of the range to zero out (exclusive).

Returns:

a reference to this instance.

Throws:

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

append

@NotNull
default R append(long offset,
                          long value,
                          int digits)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          net.openhft.chronicle.core.io.ClosedIllegalStateException

Appends a long value as a string with a specified number of digits at the given offset.

Parameters:

offset - the non-negative offset to append the string at.

value - the long value to be appended.

digits - the number of digits in the appended string.

Returns:

a reference to this instance.

Throws:

BufferOverflowException - If the capacity of this data output was exceeded.

IllegalArgumentException - If the number of digits is not compatible with the long value.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

append

@NotNull
default R append(long offset,
                          double value,
                          int decimalPlaces,
                          int digits)
                   throws BufferOverflowException,
                          IllegalArgumentException,
                          net.openhft.chronicle.core.io.ClosedIllegalStateException,
                          ArithmeticException,
                          net.openhft.chronicle.core.io.ThreadingIllegalStateException

Appends a double value as a string with a specified number of decimal places and total digits at the given offset.

Parameters:

offset - the non-negative offset to append the string at.

value - the double value to be appended.

decimalPlaces - the number of decimal places in the appended string.

digits - the total number of digits in the appended string.

Returns:

a reference to this instance.

Throws:

BufferOverflowException - If the capacity of this data output was exceeded.

IllegalArgumentException - If the number of digits or decimal places is not compatible with the double value.

ArithmeticException - If rounding errors occur during the conversion of the double value to string.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

nativeWrite

void nativeWrite(long address,
                 long position,
                 long size)
          throws BufferOverflowException,
                 net.openhft.chronicle.core.io.ClosedIllegalStateException,
                 net.openhft.chronicle.core.io.ThreadingIllegalStateException

Expert-level method that copies data directly from native memory into this BytesStore.

Parameters:

address - the address in the native memory from where data should be copied.

position - the position in the BytesStore where data should be written.

size - the size of the data, in bytes, to be copied from the native memory.

Throws:

BufferOverflowException - If the capacity of this BytesStore was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

writeUtf8

default long writeUtf8(long writeOffset,
                       @Nullable
                       @Nullable CharSequence text)
                throws BufferOverflowException,
                       net.openhft.chronicle.core.io.ClosedIllegalStateException,
                       ArithmeticException

Writes the provided text into this RandomDataOutput writing at the given writeOffset, in Utf8 format. Returns the new write position after writing the provided text.

Parameters:

writeOffset - the offset at which the text should be written.

text - the CharSequence to write, which can be null.

Returns:

the offset after the text has been written.

Throws:

BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

ArithmeticException - If errors occur during the conversion of the CharSequence to UTF-8.

See Also:

RandomDataInput.readUtf8(long, Appendable)

writeUtf8Limited

default long writeUtf8Limited(long writeOffset,
                              @Nullable
                              @Nullable CharSequence text,
                              int maxUtf8Len)
                       throws BufferOverflowException,
                              net.openhft.chronicle.core.io.ClosedIllegalStateException,
                              ArithmeticException

Writes the given text to this RandomDataOutput writing at the provided writeOffset, in Utf8 format, checking that the utf8 encoding size of the given char sequence is less or equal to the provided maxUtf8Len, otherwise IllegalArgumentException is thrown, and no bytes of this RandomDataOutput are overwritten. Returns the new write position after writing the provided text

Parameters:

writeOffset - the offset at which the text should be written.

text - the CharSequence to write, which can be null.

maxUtf8Len - the maximum length of the UTF-8 encoded text.

Returns:

the offset after the text has been written.

Throws:

IllegalArgumentException - If the UTF-8 encoding size of the text exceeds maxUtf8Len.

BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

ArithmeticException - If errors occur during the conversion of the CharSequence to UTF-8.

See Also:

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

write8bit

long write8bit(long position,
               @NotNull
               @NotNull BytesStore<?,?> bs)
        throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
               net.openhft.chronicle.core.io.ThreadingIllegalStateException

Writes a BytesStore instance to this RandomDataOutput at the given position. The length of the BytesStore content is encoded using a stop bit encoding scheme.

Parameters:

position - the position at which the BytesStore content should be written.

bs - the BytesStore instance to write.

Returns:

the offset after the BytesStore has been written.

Throws:

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

write8bit

long write8bit(long position,
               @NotNull
               @NotNull String s,
               int start,
               int length)
        throws net.openhft.chronicle.core.io.ClosedIllegalStateException,
               net.openhft.chronicle.core.io.ThreadingIllegalStateException

Writes a portion of a string to this RandomDataOutput at the given position. The length of the string is encoded using a stop bit encoding scheme.

Parameters:

position - the position at which the string should be written.

s - the string to write.

start - the starting index from where characters are to be taken from the string.

length - the number of characters to be written from the string.

Returns:

the offset after the string has been written.

Throws:

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

compareAndSwapInt

boolean compareAndSwapInt(long offset,
                          int expected,
                          int value)
                   throws BufferOverflowException,
                          net.openhft.chronicle.core.io.ClosedIllegalStateException

Performs a 32-bit compare-and-swap (CAS) operation at a given offset.

Parameters:

offset - the offset at which to perform the CAS operation.

expected - the expected current value.

value - the new value to set if the current value matches the expected value.

Returns:

true if the CAS operation was successful, false otherwise.

Throws:

BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

testAndSetInt

void testAndSetInt(long offset,
                   int expected,
                   int value)
            throws BufferOverflowException,
                   net.openhft.chronicle.core.io.ClosedIllegalStateException

Tests if the current value at the specified offset equals the expected value and, if so, sets it to the provided value.

Parameters:

offset - the offset at which to perform the test-and-set operation.

expected - the expected current value.

value - the new value to set if the current value matches the expected value.

Throws:

BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

compareAndSwapLong

boolean compareAndSwapLong(long offset,
                           long expected,
                           long value)
                    throws BufferOverflowException,
                           net.openhft.chronicle.core.io.ClosedIllegalStateException,
                           net.openhft.chronicle.core.io.ThreadingIllegalStateException

Performs a 64-bit compare-and-swap (CAS) operation at a given offset.

Parameters:

offset - the offset at which to perform the CAS operation.

expected - the expected current value.

value - the new value to set if the current value matches the expected value.

Returns:

true if the CAS operation was successful, false otherwise.

Throws:

BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

compareAndSwapFloat

boolean compareAndSwapFloat(long offset,
                            float expected,
                            float value)
                     throws net.openhft.chronicle.core.io.ClosedIllegalStateException

Performs a compare-and-swap (CAS) operation for a 32-bit float at the given offset. The CAS operation is atomic, meaning that it will compare the current value at the specified offset with the expected value and, if they are equal, it will set the value to the new one.

Parameters:

offset - the offset at which to perform the CAS operation.

expected - the expected current value.

value - the new value to set if the current value matches the expected value.

Returns:

true if the CAS operation was successful (the value was updated), false otherwise.

Throws:

BufferOverflowException - If the offset plus the size of a float exceeds the buffer's capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

compareAndSwapDouble

boolean compareAndSwapDouble(long offset,
                             double expected,
                             double value)
                      throws net.openhft.chronicle.core.io.ClosedIllegalStateException

Performs a compare-and-swap (CAS) operation for a 64-bit double at the given offset. Similar to the compareAndSwapFloat(long, float, float), this is an atomic operation.

Parameters:

offset - the offset at which to perform the CAS operation.

expected - the expected current value.

value - the new value to set if the current value matches the expected value.

Returns:

true if the CAS operation was successful (the value was updated), false otherwise.

Throws:

BufferOverflowException - If the offset plus the size of a double exceeds the buffer's capacity.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

addAndGetInt

int addAndGetInt(long offset,
                 int adding)
          throws net.openhft.chronicle.core.io.ClosedIllegalStateException

Atomically adds a 32-bit integer value to the current value at the specified offset and returns the resulting sum. This operation is atomic, which means that it's performed as a single, uninterruptible unit.

Parameters:

offset - the offset at which the current value is stored and to which the specified value is to be added.

adding - the value to add to the current value at the specified offset.

Returns:

the sum of the original value at the specified offset and the value being added.

Throws:

BufferUnderflowException - If the specified offset is not within the bounds of the buffer.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

addAndGetLong

long addAndGetLong(long offset,
                   long adding)
            throws net.openhft.chronicle.core.io.ClosedIllegalStateException

Atomically adds a 64-bit long value to the current value at the specified offset and returns the resulting sum. This operation is atomic, meaning it's performed as a single, uninterruptible unit.

Parameters:

offset - the offset where the current value is stored and to which the specified value is to be added.

adding - the value to add to the current value at the specified offset.

Returns:

the sum of the original value at the specified offset and the value being added.

Throws:

BufferUnderflowException - If the specified offset is not within the bounds of the buffer.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

addAndGetFloat

float addAndGetFloat(long offset,
                     float adding)
              throws net.openhft.chronicle.core.io.ClosedIllegalStateException

Atomically adds a 32-bit float value to the current value at the specified offset and returns the resulting sum. This operation is atomic, which implies that it's performed as a single, uninterruptible operation.

Parameters:

offset - the offset at which the current value is stored and to which the specified value is to be added.

adding - the value to add to the current value at the specified offset.

Returns:

the sum of the original value at the specified offset and the value being added.

Throws:

BufferUnderflowException - If the specified offset is not within the bounds of the buffer.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

addAndGetDouble

double addAndGetDouble(long offset,
                       double adding)
                throws net.openhft.chronicle.core.io.ClosedIllegalStateException

Atomically adds a 64-bit double value to the current value at the specified offset and returns the resulting sum. This operation is atomic, which ensures that it's performed as a single, uninterruptible unit.

Parameters:

offset - the offset where the current value is stored and to which the specified value is to be added.

adding - the value to add to the current value at the specified offset.

Returns:

the sum of the original value at the specified offset and the value being added.

Throws:

BufferUnderflowException - If the specified offset is not within the bounds of the buffer.

net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.

net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way

appendAndReturnLength

default long appendAndReturnLength(long writePosition,
                                   boolean negative,
                                   long mantissa,
                                   int exponent,
                                   boolean append0)