AbstractBytes (OpenHFT/Chronicle-Bytes 2.24ea16 API)

java.lang.Object
- net.openhft.chronicle.core.io.AbstractReferenceCounted
- - net.openhft.chronicle.bytes.AbstractBytes

Type Parameters:

U - Underlying type

All Implemented Interfaces:

Appendable, CharSequence, Bytes, BytesIn, BytesOut, BytesPrepender<Bytes>, BytesStore<Bytes,U>, ByteStringAppender<Bytes>, ByteStringParser<Bytes>, HexDumpBytesDescription<BytesOut>, HasUncheckedRandomDataInput, RandomDataInput, RandomDataOutput<Bytes>, DecimalAppender, StreamingCommon<Bytes>, StreamingDataInput<Bytes>, StreamingDataOutput<Bytes>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceCountedTracer, net.openhft.chronicle.core.io.ReferenceOwner, net.openhft.chronicle.core.io.SingleThreadedChecked

Direct Known Subclasses:

MappedBytes, UncheckedBytes, VanillaBytes
```
public abstract class AbstractBytes
extends net.openhft.chronicle.core.io.AbstractReferenceCounted
implements Bytes, HasUncheckedRandomDataInput, DecimalAppender
```
Abstract representation of Bytes.

Field Summary

Fields
Modifier and Type	Field and Description
`protected @NotNull BytesStore<Bytes<U>,U>`	`bytesStore`
`protected static boolean`	`DISABLE_THREAD_SAFETY` Deprecated.
`protected boolean`	`isPresent`
`protected long`	`readPosition`
`protected long`	`writeLimit`

Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
referenceCounted, WARN_COUNT, WARN_NS

Fields inherited from interface net.openhft.chronicle.bytes.Bytes
DEFAULT_BYTE_BUFFER_CAPACITY, MAX_CAPACITY, MAX_HEAP_CAPACITY

Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput
charToString

Fields inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
JAVA9_STRING_CODER_LATIN, JAVA9_STRING_CODER_UTF16

Fields inherited from interface net.openhft.chronicle.core.io.SingleThreadedChecked
DISABLE_SINGLE_THREADED_CHECK

Method Summary

All Methods Instance Methods Concrete Methods Deprecated Methods
Modifier and Type	Method and Description
`@NotNull UncheckedRandomDataInput`	`acquireUncheckedInput()` Returns a view of a memory segment providing memory read operations with potentially unchecked memory boundaries.
`long`	`addressForRead(long offset)` Retrieves the underlying memory address for reading.
`long`	`addressForWrite(long offset)` Retrieves the underlying memory address for writing.
`long`	`addressForWritePosition()` Retrieves the underlying memory address for writing at the current write position.
`void`	`append(boolean negative, long mantissa, int exponent)` Appends a numeric value in decimal form with the specified mantissa and exponent, handling negative values and decimal point placement.
`@NotNull AbstractBytes<U>`	`append(double d)` Appends the string representation of the given double value to the bytes.
`@NotNull Bytes<U>`	`append(double d, int decimalPlaces)` Appends a double in decimal notation to a specific number of decimal places.
`@NotNull Bytes<U>`	`append(float f)` Appends the string representation of the given float value to the bytes.
`@NotNull Bytes<U>`	`append(int value)` Appends an int in decimal to this.
`@NotNull Bytes<U>`	`append(long value)` Appends a long value in decimal.
`long`	`appendAndReturnLength(long writePosition, boolean negative, long mantissa, int exponent, boolean append0)`
`int`	`byteCheckSum()` Returns the bytes sum of the readable bytes in this BytesStore.
`int`	`byteCheckSum(int start, int end)` Returns the bytes sum between the specified indexes; start (inclusive) and end (exclusive).
`int`	`byteCheckSum(long start, long end)` Returns the bytes sum between the specified indexes; start (inclusive) and end (exclusive).
`@NotNull BytesStore`	`bytesStore()` Returns the backing BytesStore that this Bytes object wraps.
`protected void`	`bytesStore(BytesStore<Bytes<U>,U> bytesStore)`
`boolean`	`canReadDirect(long length)` Checks if the specified length of bytes can be read directly from native memory.
`boolean`	`canWriteDirect(long count)` Determines if the buffer can write the specified count of bytes directly.
`long`	`capacity()` Provides the maximum limit that can be set for the ByteStore.
`@NotNull Bytes<U>`	`clear()` Clears the content of this Bytes object and resets its state.
`@NotNull Bytes<U>`	`clearAndPad(long length)` Clears the buffer and pads it with a specified length to allow prepending later.
`@NotNull Bytes<U>`	`compact()` Compacts this Bytes object by moving the read position to the start.
`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.
`BytesStore<Bytes<U>,U>`	`copy()` Creates and returns a deep copy of this Bytes object, including the data between `RandomCommon.readPosition()` and `RandomCommon.readLimit()`.
`int`	`copyTo(byte[] bytes)` Copies data from this byte source into a byte array.
`Decimaliser`	`decimaliser()` Gets the Decimaliser currently associated with this ByteStringAppender.
`Bytes<U>`	`decimaliser(Decimaliser decimaliser)` Associates a Decimaliser with this ByteStringAppender.
`boolean`	`equals(Object obj)`
`boolean`	`fpAppend0()`
`Bytes<U>`	`fpAppend0(boolean append0)`
`int`	`hashCode()`
`byte[]`	`internalNumberBuffer()` Deprecated.
`boolean`	`isDirectMemory()` Checks if this BytesStore uses direct memory.
`boolean`	`isElastic()` Checks if this Bytes object is elastic, meaning it can dynamically resize when more data is written than its current `Bytes.realCapacity()`.
`boolean`	`isImmutableEmptyByteStore()` Returns if this ByteStore is an immutable empty ByteStore or if it is backed by an immutable empty ByteStore.
`int`	`lastDecimalPlaces()` Returns the number of decimal places in the last parsed floating-point number (from the `ByteStringParser.parseDouble()` or `ByteStringParser.parseLongDecimal()` methods).
`void`	`lastDecimalPlaces(int lastDecimalPlaces)` Sets the number of decimal places in the last parsed number.
`boolean`	`lastNumberHadDigits()` Returns whether the last parsed number had any digits.
`void`	`lastNumberHadDigits(boolean lastNumberHadDigits)` Sets whether the last parsed number had any digits.
`int`	`length()` This method is inherited from CharSequence so result should be the length of the contained chars sequence although it actually returns the number of underlying bytes.
`boolean`	`lenient()`
`void`	`lenient(boolean lenient)` When there is no more data to read, return zero, `false` and empty string.
`void`	`move(long from, long to, long length)` Moves a sequence of bytes within this BytesStore from the source to destination index.
`void`	`nativeRead(long position, long address, long size)` Expert-level method for transferring data from this byte source to native memory.
`void`	`nativeWrite(long address, long position, long size)` Expert-level method that copies data directly from native memory into this BytesStore.
`int`	`peekUnsignedByte()` Peeks (reads without moving the read pointer) the next unsigned byte from the input stream.
`int`	`peekUnsignedByte(long offset)` Reads an unsigned byte value from a specific offset.
`protected void`	`performRelease()`
`@NotNull Bytes<U>`	`prewrite(byte[] bytes)` Writes a byte array backward in binary format.
`@NotNull Bytes<U>`	`prewrite(@NotNull BytesStore bytes)` Writes a BytesStore instance backward in binary format.
`@NotNull Bytes<U>`	`prewriteByte(byte i8)` Writes a byte backward in binary format.
`@NotNull Bytes<U>`	`prewriteInt(int i)` Writes an int (4-byte int) backward in binary format.
`@NotNull Bytes<U>`	`prewriteLong(long l)` Writes a long (8-byte int) backward in binary format.
`protected long`	`prewriteOffsetPositionMoved(long subtracting)`
`@NotNull Bytes<U>`	`prewriteShort(short i)` Writes a short (2-byte int) backward in binary format.
`int`	`read(byte[] bytes, int off, int len)` Reads the input stream into the provided byte array, starting from the given offset and reading up to the specified length.
`long`	`read(long offsetInRDI, byte[] bytes, int offset, int length)` Reads a sequence of bytes from the specified offset into a byte array.
`byte`	`readByte()` Reads a byte value from the input stream.
`byte`	`readByte(long offset)` Reads a byte value from a specific offset.
`protected void`	`readCheckOffset(long offset, long adding, boolean given)`
`double`	`readDouble()` Reads a 64-bit floating-point number from the input stream.
`double`	`readDouble(long offset)` Reads a 64-bit floating point value from a specified offset.
`float`	`readFloat()` Reads a 32-bit floating-point number from the input stream.
`float`	`readFloat(long offset)` Reads a 32-bit floating point value from a specified offset.
`int`	`readInt()` Reads a 32-bit integer value from the input stream.
`int`	`readInt(long offset)` Reads a 32-bit integer value from a specific offset.
`long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`@NotNull Bytes<U>`	`readLimit(long limit)` Sets the read limit of this StreamingDataInput.
`long`	`readLong()` Reads a 64-bit long value from the input stream.
`long`	`readLong(long offset)` Reads a 64-bit long value from a specific offset.
`protected long`	`readOffsetPositionMoved(long adding)`
`long`	`readPosition()` Returns the read position.
`@NotNull Bytes<U>`	`readPosition(long position)` Sets the read position of this StreamingDataInput.
`long`	`readPositionForHeader(boolean skipPadding)` Obtains the current read position, optionally skipping padding bytes if specified.
`short`	`readShort()` Reads a 16-bit short value from the input stream.
`short`	`readShort(long offset)` Reads a short value from a specific offset.
`@NotNull Bytes<U>`	`readSkip(long bytesToSkip)` Skips the specified number of bytes by advancing the read position.
`int`	`readUnsignedByte()` Reads the next unsigned 8-bit value from the input stream.
`int`	`readUnsignedByte(long offset)` Reads an unsigned byte value from a specific offset.
`byte`	`readVolatileByte(long offset)` Reads a volatile 8-bit byte value from a specified offset.
`int`	`readVolatileInt()` Reads a volatile (concurrently mutable) integer value from the input stream.
`int`	`readVolatileInt(long offset)` Reads a volatile 32-bit integer value from a specified offset.
`long`	`readVolatileLong()` Reads a volatile (concurrently mutable) long value from the input stream.
`long`	`readVolatileLong(long offset)` Reads a volatile 64-bit long value from a specified offset.
`short`	`readVolatileShort(long offset)` Reads a volatile 16-bit short value from a specified offset.
`long`	`realCapacity()` Returns the actual capacity of the ByteStore before any resizing occurs.
`protected int`	`safeCopySize()`
`long`	`start()`
`boolean`	`startsWith(@Nullable BytesStore bytesStore)` Returns if the content of this BytesStore starts with bytes equal to the content of a specified 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.
`@NotNull String`	`toString()`
`void`	`uncheckedReadSkipBackOne()` Unchecked version of readSkip(-1).
`void`	`uncheckedReadSkipOne()` Unchecked version of readSkip(1).
`int`	`uncheckedReadUnsignedByte()` Reads the next unsigned 8-bit value from the input stream without performing boundary checks.
`protected void`	`uncheckedWritePosition(long writePosition)`
`U`	`underlyingObject()`
`@NotNull Bytes<U>`	`write(byte[] byteArray, int offset, int length)` Writes the specified number of bytes from the given `byteArray` into the output stream, starting from the given offset.
`Bytes<U>`	`write(@NotNull BytesStore<?,?> bytes)` Writes all available data from the specified `BytesStore` into the output stream.
`@NotNull Bytes<U>`	`write(long offsetInRDO, byte[] byteArray, int offset, 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 offsetInRDO, @NotNull ByteBuffer bytes, int offset, int length)` Copies a segment from the provided ByteBuffer into this data output.
`@NotNull Bytes<U>`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)` Copies a segment from the provided RandomDataInput into this data output.
`@NotNull Bytes<U>`	`write(@NotNull RandomDataInput bytes)` Writes all available data from the specified `RandomDataInput` into the output stream.
`@NotNull Bytes<U>`	`write8bit(@Nullable BytesStore bs)`
`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.
`@NotNull Bytes<U>`	`write8bit(@NotNull String text, int start, int length)` Writes a subsequence of a String as an 8-bit string to the data stream.
`@NotNull Bytes<U>`	`writeBoolean(boolean flag)` Writes a boolean value to this output stream.
`@NotNull Bytes<U>`	`writeByte(byte i8)` Writes a byte to the data stream.
`@NotNull Bytes<U>`	`writeByte(long offset, byte i)` Writes a byte at the specified non-negative offset.
`protected void`	`writeCheckOffset(long offset, long adding)`
`@NotNull Bytes<U>`	`writeDouble(double d)` Writes a double-precision floating-point number to the data stream.
`@NotNull Bytes<U>`	`writeDouble(long offset, double d)` Writes a double-precision floating-point value at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeDoubleAndInt(double d, int i)` Writes a double-precision floating-point number followed by an integer to the data stream.
`@NotNull Bytes<U>`	`writeFloat(float f)` Writes a floating-point number to the data stream.
`@NotNull Bytes<U>`	`writeFloat(long offset, float d)` Writes a single-precision floating-point value at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeInt(int i)` Writes an integer to the data stream.
`@NotNull Bytes<U>`	`writeInt(long offset, int i)` Writes an integer value at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeIntAdv(int i, int advance)` Writes an integer to the data stream, then advances the write position by the specified amount.
`long`	`writeLimit()` Retrieves the maximum writable position within the buffer.
`@NotNull Bytes<U>`	`writeLimit(long limit)` Sets the limit for writing to the data stream.
`@NotNull Bytes<U>`	`writeLong(long i64)` Writes a long integer to the data stream.
`@NotNull Bytes<U>`	`writeLong(long offset, long i)` Writes a long integer value at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeLongAdv(long i64, int advance)` Writes a long integer to the data stream, then advances the write position by the specified amount.
`protected long`	`writeOffsetPositionMoved(long adding)`
`protected long`	`writeOffsetPositionMoved(long adding, long advance)`
`@NotNull Bytes<U>`	`writeOrderedInt(int i)` Writes an integer value to this output stream using an ordered-writing mechanism.
`@NotNull Bytes<U>`	`writeOrderedInt(long offset, int i)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`@NotNull Bytes<U>`	`writeOrderedLong(long i)` Writes a long value to this output stream using an ordered-writing mechanism.
`@NotNull Bytes<U>`	`writeOrderedLong(long offset, long i)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`long`	`writePosition()` Returns the write position.
`@NotNull Bytes<U>`	`writePosition(long position)` Sets the current write position in the data stream.
`@NotNull Bytes<U>`	`writeShort(long offset, short i)` Writes a short integer at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeShort(short i16)` Writes a short integer to the data stream.
`@NotNull Bytes<U>`	`writeSkip(long bytesToSkip)` Skips a specified number of bytes from the current write position in the data stream.
`@NotNull Bytes<U>`	`writeSome(@NotNull ByteBuffer buffer)` Writes the available data from the provided `ByteBuffer` into this Bytes object.
`@NotNull Bytes<U>`	`writeVolatileByte(long offset, byte i8)` Writes a volatile byte at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeVolatileInt(long offset, int i32)` Writes a volatile integer at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeVolatileLong(long offset, long i64)` Writes a volatile long integer at the specified non-negative offset.
`@NotNull Bytes<U>`	`writeVolatileShort(long offset, short i16)` Writes a volatile short at the specified non-negative offset.

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted
addReferenceChangeListener, assertReferencesReleased, backgroundPerformRelease, canReleaseInBackground, clearUsedByThread, createdHere, disableReferenceTracing, enableReferenceTracing, refCount, referenceCountedUnmonitored, referenceId, release, releaseLast, removeReferenceChangeListener, reserve, reservedBy, reserveTransfer, singleThreadedCheckDisabled, singleThreadedCheckReset, threadSafetyCheck, throwExceptionIfNotReleased, throwExceptionIfReleased, tryReserve, unmonitor, warnAndReleaseIfNotReleased

Methods inherited from class java.lang.Object
clone, finalize, getClass, notify, notifyAll, wait, wait, wait

Methods inherited from interface net.openhft.chronicle.bytes.Bytes
allocateDirect, allocateDirect, allocateElasticDirect, allocateElasticDirect, allocateElasticOnHeap, allocateElasticOnHeap, bytesForRead, bytesForWrite, copyTo, copyTo, directFrom, elasticByteBuffer, elasticByteBuffer, elasticByteBuffer, elasticHeapByteBuffer, elasticHeapByteBuffer, empty, ensureCapacity, forFieldGroup, from, from, fromDirect, fromHexString, indexOf, indexOf, isClear, isEqual, readMarshallableLength16, readWithLength, readWrite, safeLimit, sharedMemory, toHexString, toHexString, toHexString, toString, toString, toString, unchecked, unchecked, unwrite, valueOf, wrapForRead, wrapForRead, wrapForWrite, wrapForWrite, write, writeMarshallableLength16

Methods inherited from interface net.openhft.chronicle.bytes.BytesStore
addAndGetDouble, addAndGetDoubleNotAtomic, addAndGetFloat, addAndGetFloatNotAtomic, addAndGetInt, addAndGetIntNotAtomic, addAndGetLong, addAndGetShortNotAtomic, addAndGetUnsignedByteNotAtomic, charAt, cipher, cipher, compareAndSwapDouble, compareAndSwapFloat, contentEquals, elasticByteBuffer, endsWith, equalBytes, follow, forFields, from, hash, inside, inside, isEmpty, isEqual, lazyNativeBytesStoreWithFixedCapacity, nativePointer, nativeStore, nativeStoreFrom, nativeStoreWithFixedCapacity, startsWith, subSequence, to8bitString, toDebugString, toDebugString, wrap, wrap, wrap, writeMaxInt, writeMaxLong, zeroOut

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, append, write, write, writeBoolean, writeByte, writeInt24, writeOrderedDouble, writeOrderedFloat, writeUnsignedByte, writeUnsignedInt, writeUnsignedShort, writeUtf8, writeUtf8Limited, writeVolatileDouble, writeVolatileFloat

Methods inherited from interface java.lang.CharSequence
chars, codePoints

Methods inherited from interface net.openhft.chronicle.bytes.BytesIn
bytesMethodReader, bytesMethodReaderBuilder, readObject

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataInput
canReadDirect, compareUtf8, copyTo, createCharToString, fastHash, findByte, parseLong, peekVolatileInt, printable, readBoolean, readIncompleteLong, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8Limited, readUtf8Limited, readVolatileDouble, readVolatileFloat, subBytes, toByteArray, toTemporaryDirectByteBuffer

Methods inherited from interface net.openhft.chronicle.bytes.ByteStringParser
parse8bit, parse8bit, parse8bit, parse8bit, parse8bit, parseBigDecimal, parseBoolean, parseBoolean, parseDouble, parseFlexibleLong, parseFloat, parseInt, parseLong, parseLongDecimal, parseUtf8, parseUtf8, parseUtf8, reader, skipTo

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataInput
inputStream, parseHexLong, parseUtf8, parseUtf8, rawReadByte, rawReadInt, rawReadLong, read, read, read, read, read, read8bit, read8bit, read8bit, readBigDecimal, readBigInteger, readBoolean, readChar, readEnum, readHistogram, readIncompleteLong, readInt24, readLimitToCapacity, readPositionRemaining, readPositionUnlimited, readStopBit, readStopBitChar, readStopBitDecimal, readStopBitDouble, readUnsignedInt, readUnsignedInt24, readUnsignedShort, readUtf8, readUtf8, readUtf8, readUtf8, readWithLength, readWithLength, readWithLength0, unsafeRead, unsafeReadObject, unsafeReadObject

Methods inherited from interface net.openhft.chronicle.bytes.BytesOut
bytesMethodWriter, writeObject

Methods inherited from interface net.openhft.chronicle.bytes.ByteStringAppender
append, append, append, append, append, append8bit, append8bit, append8bit, append8bit, append8bit, appendBase, appendBase16, appendBase16, appendDateMillis, appendDecimal, appendTimeMillis, writer

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, copyFrom, outputStream, rawWriteByte, rawWriteInt, rawWriteLong, unsafeWrite, unsafeWriteObject, unsafeWriteObject, write, write, write, write, write, write8bit, write8bit, write8bit, writeBigDecimal, writeBigInteger, writeChar, writeEnum, writeHistogram, writeInt24, writePositionForHeader, writePositionRemaining, writeSome, writeStopBit, writeStopBit, writeStopBit, writeStopBitDecimal, writeUnsignedByte, writeUnsignedInt, writeUnsignedInt24, writeUnsignedShort, writeUtf8, writeUtf8, writeWithLength

Methods inherited from interface net.openhft.chronicle.bytes.BytesPrepender
prepend

Methods inherited from interface net.openhft.chronicle.bytes.HexDumpBytesDescription
adjustHexDumpIndentation, retainedHexDumpDescription, writeHexDumpDescription

Methods inherited from interface net.openhft.chronicle.core.io.SingleThreadedChecked
singleThreadedCheckDisabled, singleThreadedCheckReset

Methods inherited from interface net.openhft.chronicle.core.io.ReferenceCountedTracer
onReleased

- Field Detail
 - DISABLE_THREAD_SAFETY
```
@Deprecated
protected static final boolean DISABLE_THREAD_SAFETY
```
 Deprecated.
 - bytesStore
```
@NotNull
protected @NotNull BytesStore<Bytes,U> bytesStore
```
 - readPosition
```
protected long readPosition
```
 - writeLimit
```
protected long writeLimit
```
 - isPresent
```
protected boolean isPresent
```
- Method Detail
 - isDirectMemory
```
public boolean isDirectMemory()
```
 Description copied from interface: BytesStore
 
 Checks if this BytesStore uses direct memory.
 
 Specified by:
 
 isDirectMemory in interface BytesStore<Bytes,U>
 
 Returns:
 
 true if it uses direct memory, false otherwise
 - canReadDirect
```
public boolean canReadDirect(long length)
```
 Description copied from interface: RandomDataInput
 
 Checks if the specified length of bytes can be read directly from native memory.
 
 Specified by:
 
 canReadDirect in interface RandomDataInput
 
 Parameters:
 
 length - the number of bytes to check.
 
 Returns:
 
 true if the byte sequence is backed by direct memory and the remaining bytes are more than or equal to the specified length, false otherwise.
 - move
```
public void move(long from,
 long to,
 long length)
 throws BufferUnderflowException,
 IllegalStateException,
 ArithmeticException
```
 Description copied from interface: BytesStore
 
 Moves a sequence of bytes within this BytesStore from the source to destination index.
 
 Specified by:
 
 move in interface BytesStore<Bytes,U>
 
 Parameters:
 
 from - the index of the first byte to be moved
 
 to - the index where the first byte should be moved to
 
 length - the number of bytes to be moved
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to be moved
 
 IllegalStateException - if the BytesStore is in an unusable state
 
 ArithmeticException - if the move would result in an index overflow
 - compact
```
@NotNull
public @NotNull Bytes compact()
 throws IllegalStateException
```
 Description copied from interface: Bytes
 
 Compacts this Bytes object by moving the read position to the start.
 This operation is useful to free up space for writing by discarding bytes that have already been read.
 
 Specified by:
 
 compact in interface Bytes
 
 Returns:
 
 This Bytes object, for method chaining.
 
 Throws:
 
 IllegalStateException - if this Bytes object has been previously released.
 - clear
```
@NotNull
public @NotNull Bytes clear()
 throws IllegalStateException
```
 Description copied from interface: Bytes
 
 Clears the content of this Bytes object and resets its state.
 
 Specified by:
 
 clear in interface Bytes
 
 Specified by:
 
 clear in interface StreamingCommon<Bytes>
 
 Returns:
 
 This Bytes object.
 
 Throws:
 
 IllegalStateException - if this Bytes object has been previously released.
 - clearAndPad
```
@NotNull
public @NotNull Bytes clearAndPad(long length)
 throws BufferOverflowException
```
 Description copied from interface: BytesPrepender
 
 Clears the buffer and pads it with a specified length to allow prepending later. clearAndPad(0) is equivalent to clear().
 
 Specified by:
 
 clearAndPad in interface BytesPrepender<Bytes>
 
 Parameters:
 
 length - the padding length
 
 Returns:
 
 this instance, after clearing and padding
 
 Throws:
 
 BufferOverflowException - if the length is greater than the difference of capacity() and start()
 - readLimit
```
public long readLimit()
```
 If the resource is closed, the returned value is unspecified.
 
 Returns:
 
 the highest offset or position allowed for this buffer.
 - writeLimit
```
public long writeLimit()
```
 Retrieves the maximum writable position within the buffer.
 If the resource is closed, the returned value is unspecified.
 
 Returns:
 
 the write limit
 - realCapacity
```
public long realCapacity()
```
 Description copied from interface: BytesStore
 
 Returns the actual capacity of the ByteStore before any resizing occurs.
 
 Specified by:
 
 realCapacity in interface Bytes
 
 Specified by:
 
 realCapacity in interface BytesStore<Bytes,U>
 
 Specified by:
 
 realCapacity in interface RandomDataInput
 
 Specified by:
 
 realCapacity in interface StreamingDataOutput<Bytes>
 
 Returns:
 
 the current capacity of the ByteStore
 - canWriteDirect
```
public boolean canWriteDirect(long count)
```
 Description copied from interface: StreamingDataOutput
 
 Determines if the buffer can write the specified count of bytes directly. The default implementation always returns false. Override this method in sub-classes to provide specific implementation.
 
 Specified by:
 
 canWriteDirect in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 count - the number of bytes to write.
 
 Returns:
 
 true if the buffer can write the specified count of bytes directly, false otherwise.
 - capacity
```
public long capacity()
```
 Description copied from interface: BytesStore
 
 Provides the maximum limit that can be set for the ByteStore.
 
 Specified by:
 
 capacity in interface BytesStore<Bytes,U>
 
 Returns:
 
 the maximum capacity of the ByteStore
 - underlyingObject
```
@Nullable
public U underlyingObject()
```
 Specified by:
 
 underlyingObject in interface BytesStore<Bytes,U>
 
 Returns:
 
 the underlying object being wrapped, if there is one, or null if not.
 - length
```
public int length()
```
 Description copied from interface: BytesStore
 
 This method is inherited from CharSequence so result should be the length of the contained chars sequence although it actually returns the number of underlying bytes. These 2 numbers are only the same if the encoding we are using is single char for single byte.
 
 Specified by:
 
 length in interface CharSequence
 
 Specified by:
 
 length in interface BytesStore<Bytes,U>
 
 Returns:
 
 length in bytes to read or Integer.MAX_VALUE if longer.
 - start
```
public long start()
```
 Returns:
 
 The smallest position allowed in this buffer.
 - readPosition
```
public long readPosition()
```
 Returns the read position.
 The read position is start() <= readPosition() && readPosition() <= readLimit() && readPosition < safeLimit()
 If the resource is closed, the returned value is unspecified.
 
 Returns:
 
 position to read from.
 - writePosition
```
public long writePosition()
```
 Returns the write position.
 The write position is readPosition() <= writePosition() && writePosition() <= writeLimit()
 If the resource is closed, the returned value is unspecified.
 
 Returns:
 
 position to write to.
 - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
 int expected,
 int value)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Perform a 32-bit CAS at a given offset.
 
 Specified by:
 
 compareAndSwapInt in interface BytesStore<Bytes,U>
 
 Specified by:
 
 compareAndSwapInt in interface RandomDataInput
 
 Specified by:
 
 compareAndSwapInt in interface RandomDataOutput<Bytes>
 
 Parameters:
 
 offset - to perform CAS
 
 expected - value
 
 value - to set
 
 Returns:
 
 true, if successful.
 
 Throws:
 
 BufferOverflowException - if the capacity of this RandomDataOutput was exceeded.
 
 IllegalStateException - if released
 - testAndSetInt
```
public void testAndSetInt(long offset,
 int expected,
 int value)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Tests if the current value at the specified offset equals the expected value and, if so, sets it to the provided value.
 
 Specified by:
 
 testAndSetInt in interface RandomDataInput
 
 Specified by:
 
 testAndSetInt in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if this RandomDataOutput has been previously released.
 - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
 long expected,
 long value)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Perform a 64-bit CAS at a given offset.
 
 Specified by:
 
 compareAndSwapLong in interface BytesStore<Bytes,U>
 
 Specified by:
 
 compareAndSwapLong in interface RandomDataInput
 
 Specified by:
 
 compareAndSwapLong in interface RandomDataOutput<Bytes>
 
 Parameters:
 
 offset - to perform CAS
 
 expected - value
 
 value - to set
 
 Returns:
 
 true, if successful.
 
 Throws:
 
 BufferOverflowException - if the capacity of this RandomDataOutput was exceeded.
 
 IllegalStateException - if released
 - append
```
@NotNull
public @NotNull AbstractBytes append(double d)
 throws BufferOverflowException,
 IllegalStateException
```
 Appends the string representation of the given double value to the bytes. First, it tries to convert the double value using the Decimalizer instance. If that fails, it falls back to converting the double to a String and appending it.
 
 Specified by:
 
 append in interface ByteStringAppender<Bytes>
 
 Parameters:
 
 d - the double value to append.
 
 Returns:
 
 this Bytes instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space to write the double.
 
 IllegalStateException - if this buffer is closed.
 - append
```
@NotNull
public @NotNull Bytes append(float f)
 throws BufferOverflowException,
 IllegalStateException
```
 Appends the string representation of the given float value to the bytes. First, it tries to convert the float value using the Decimalizer instance. If that fails, it falls back to converting the float to a String and appending it.
 
 Specified by:
 
 append in interface ByteStringAppender<Bytes>
 
 Parameters:
 
 f - the float value to append.
 
 Returns:
 
 this Bytes instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space to write the float.
 
 IllegalStateException - if this buffer is closed.
 - append
```
@NotNull
public @NotNull Bytes append(int value)
 throws BufferOverflowException,
 IllegalArgumentException,
 IllegalStateException
```
 Description copied from interface: ByteStringAppender
 
 Appends an int in decimal to this.
 
 Specified by:
 
 append in interface ByteStringAppender<Bytes>
 
 Parameters:
 
 value - the integer value to append
 
 Returns:
 
 this
 
 Throws:
 
 BufferOverflowException - if the relative append operation exceeds the underlying buffer's capacity
 
 IllegalStateException - if the underlying buffer was released
 
 IllegalArgumentException
 - append
```
@NotNull
public @NotNull Bytes append(long value)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: ByteStringAppender
 
 Appends a long value in decimal.
 
 Specified by:
 
 append in interface ByteStringAppender<Bytes>
 
 Parameters:
 
 value - the long number to append
 
 Returns:
 
 this
 
 Throws:
 
 BufferOverflowException - if the relative append operation exceeds the underlying buffer's capacity
 
 IllegalStateException - if the underlying buffer was released
 - decimaliser
```
public Decimaliser decimaliser()
```
 Description copied from interface: ByteStringAppender
 
 Gets the Decimaliser currently associated with this ByteStringAppender.
 
 Specified by:
 
 decimaliser in interface ByteStringAppender<Bytes>
 
 Returns:
 
 The Decimaliser currently associated with this ByteStringAppender.
 - decimaliser
```
public Bytes decimaliser(Decimaliser decimaliser)
```
 Description copied from interface: ByteStringAppender
 
 Associates a Decimaliser with this ByteStringAppender.
 The Decimaliser is an interface which can be implemented to provide custom logic for rendering decimal numbers in this ByteStringAppender.
 
 Specified by:
 
 decimaliser in interface ByteStringAppender<Bytes>
 
 Parameters:
 
 decimaliser - The Decimaliser to be associated with this ByteStringAppender.
 
 Returns:
 
 The ByteStringAppender instance with the Decimaliser set.
 - fpAppend0
```
public boolean fpAppend0()
```
 Specified by:
 
 fpAppend0 in interface ByteStringAppender<Bytes>
 
 Returns:
 
 whether floating point add .0 to indicate it is a floating point even if redundant.
 - fpAppend0
```
public Bytes fpAppend0(boolean append0)
```
 Specified by:
 
 fpAppend0 in interface ByteStringAppender<Bytes>
 
 Parameters:
 
 append0 - Does floating point add .0 to indicate it is a floating point even if redundant.
 
 Returns:
 
 this
 - append
```
public void append(boolean negative,
 long mantissa,
 int exponent)
```
 Appends a numeric value in decimal form with the specified mantissa and exponent, handling negative values and decimal point placement.
 
 Specified by:
 
 append in interface DecimalAppender
 
 Parameters:
 
 negative - indicates if the number is negative.
 
 mantissa - the mantissa of the number to append.
 
 exponent - the exponent indicating the position of the decimal point.
 - appendAndReturnLength
```
public long appendAndReturnLength(long writePosition,
 boolean negative,
 long mantissa,
 int exponent,
 boolean append0)
```
 Specified by:
 
 appendAndReturnLength in interface RandomDataOutput<Bytes>
 - append
```
@NotNull
public @NotNull Bytes append(double d,
 int decimalPlaces)
 throws BufferOverflowException,
 IllegalArgumentException,
 IllegalStateException,
 ArithmeticException
```
 Description copied from interface: ByteStringAppender
 
 Appends a double in decimal notation to a specific number of decimal places. Trailing zeros are not truncated.
 If the number would normally be printed with more decimal places, the number is rounded.
 
 Specified by:
 
 append in interface ByteStringAppender<Bytes>
 
 Parameters:
 
 d - to append
 
 decimalPlaces - to always produce
 
 Returns:
 
 this
 
 Throws:
 
 BufferOverflowException - if the capacity of the underlying buffer was exceeded
 
 IllegalArgumentException - if the decimalPlaces is negative or too large
 
 IllegalStateException - if the underlying buffer was released
 
 ArithmeticException
 - readPosition
```
@NotNull
public @NotNull Bytes readPosition(long position)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Sets the read position of this StreamingDataInput.
 
 Specified by:
 
 readPosition in interface StreamingDataInput<Bytes>
 
 Parameters:
 
 position - the new read position, must be non-negative
 
 Returns:
 
 this StreamingDataInput instance, for chaining
 
 Throws:
 
 BufferUnderflowException - if the new position is greater than the limit
 
 IllegalStateException - if a required state for this operation is not met
 - readLimit
```
@NotNull
public @NotNull Bytes readLimit(long limit)
 throws BufferUnderflowException
```
 Description copied from interface: StreamingDataInput
 
 Sets the read limit of this StreamingDataInput.
 
 Specified by:
 
 readLimit in interface StreamingDataInput<Bytes>
 
 Parameters:
 
 limit - the new read limit, must be non-negative
 
 Returns:
 
 this StreamingDataInput instance, for chaining
 
 Throws:
 
 BufferUnderflowException - if the new limit is less than the read position
 - writePosition
```
@NotNull
public @NotNull Bytes writePosition(long position)
 throws BufferOverflowException
```
 Description copied from interface: StreamingDataOutput
 
 Sets the current write position in the data stream. The write position indicates the point where the next write operation will begin. Calling this method does not modify the data in the stream; it only changes the position where future write operations will take place.
 
 Specified by:
 
 writePosition in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 position - The new write position. It must be a non-negative number.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if the specified position exceeds the limit of the data buffer.
 - readSkip
```
@NotNull
public @NotNull Bytes readSkip(long bytesToSkip)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Skips the specified number of bytes by advancing the read position. The number of bytes to skip must be less than or equal to the read limit.
 
 Specified by:
 
 readSkip in interface StreamingDataInput<Bytes>
 
 Parameters:
 
 bytesToSkip - the number of bytes to skip
 
 Returns:
 
 this StreamingDataInput instance, for chaining
 
 Throws:
 
 BufferUnderflowException - if the new read position is outside the limits of the data source
 
 IllegalStateException - if a required state for this operation is not met
 - readPositionForHeader
```
public long readPositionForHeader(boolean skipPadding)
```
 Description copied from interface: StreamingDataInput
 
 Obtains the current read position, optionally skipping padding bytes if specified. Useful when reading data with headers that may include padding.
 
 Specified by:
 
 readPositionForHeader in interface StreamingDataInput<Bytes>
 
 Parameters:
 
 skipPadding - if true, aligns the read position to a 4-byte boundary by skipping padding bytes
 
 Returns:
 
 the current read position
 - uncheckedReadSkipOne
```
public void uncheckedReadSkipOne()
```
 Description copied from interface: StreamingDataInput
 
 Unchecked version of readSkip(1). This method skips one byte without performing any limit checks. Use this method only when you are certain that it is safe to do so, and you have identified a performance issue with readSkip(1).
 
 Specified by:
 
 uncheckedReadSkipOne in interface StreamingDataInput<Bytes>
 - uncheckedReadSkipBackOne
```
public void uncheckedReadSkipBackOne()
```
 Description copied from interface: StreamingDataInput
 
 Unchecked version of readSkip(-1). This method skips back one byte without performing any limit checks. Use this method only when you are certain that it is safe to do so, and you have identified a performance issue with readSkip(-1).
 
 Specified by:
 
 uncheckedReadSkipBackOne in interface StreamingDataInput<Bytes>
 - writeSkip
```
@NotNull
public @NotNull Bytes writeSkip(long bytesToSkip)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Skips a specified number of bytes from the current write position in the data stream. This method adjusts the write position either forward or backward based on the value of bytesToSkip. The new position should not exceed the write limit.
 
 Specified by:
 
 writeSkip in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 bytesToSkip - The number of bytes to skip. This can be a negative number to move the position backward.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if the new position calculated by the skip operation falls outside the limits of the data buffer.
 
 IllegalStateException - if released
 - writeLimit
```
@NotNull
public @NotNull Bytes writeLimit(long limit)
 throws BufferOverflowException
```
 Description copied from interface: StreamingDataOutput
 
 Sets the limit for writing to the data stream. No data can be written beyond this limit. If an attempt is made to write data beyond this limit, a BufferOverflowException will be thrown.
 
 Specified by:
 
 writeLimit in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 limit - The new write limit. It must be a non-negative number.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if the specified limit is less than the current write position.
 - performRelease
```
protected void performRelease()
```
 Specified by:
 
 performRelease in class net.openhft.chronicle.core.io.AbstractReferenceCounted
 - readUnsignedByte
```
public int readUnsignedByte()
 throws IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads the next unsigned 8-bit value from the input stream. If there is no byte available, it returns -1.
 
 Specified by:
 
 readUnsignedByte in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the next unsigned 8-bit value or -1
 
 Throws:
 
 IllegalStateException - if a required state for this operation is not met
 - readUnsignedByte
```
public int readUnsignedByte(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads an unsigned byte value from a specific offset. The value is returned as an int in order to represent the unsigned byte as a positive value.
 
 Specified by:
 
 readUnsignedByte in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the unsigned byte value is read.
 
 Returns:
 
 the unsigned byte value interpreted as a positive int.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - uncheckedReadUnsignedByte
```
public int uncheckedReadUnsignedByte()
```
 Description copied from interface: StreamingDataInput
 
 Reads the next unsigned 8-bit value from the input stream without performing boundary checks. If there is no byte available, it returns -1. Use this method with caution as it bypasses checks for data availability.
 
 Specified by:
 
 uncheckedReadUnsignedByte in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the next unsigned 8-bit value or -1
 - readByte
```
public byte readByte()
 throws IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a byte value from the input stream.
 
 Specified by:
 
 readByte in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the byte value
 
 Throws:
 
 IllegalStateException - if a required state for this operation is not met
 - peekUnsignedByte
```
public int peekUnsignedByte()
 throws IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Peeks (reads without moving the read pointer) the next unsigned byte from the input stream.
 
 Specified by:
 
 peekUnsignedByte in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the peeked byte value
 
 Throws:
 
 IllegalStateException - if a required state for this operation is not met
 - readShort
```
public short readShort()
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a 16-bit short value from the input stream.
 
 Specified by:
 
 readShort in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the 16-bit short value
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - readInt
```
public int readInt()
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a 32-bit integer value from the input stream.
 
 Specified by:
 
 readInt in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the 32-bit integer value
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - readVolatileByte
```
public byte readVolatileByte(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 8-bit byte value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Specified by:
 
 readVolatileByte in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the byte value is read.
 
 Returns:
 
 the volatile byte value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readVolatileShort
```
public short readVolatileShort(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 16-bit short value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Specified by:
 
 readVolatileShort in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the short value is read.
 
 Returns:
 
 the volatile short value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readVolatileInt
```
public int readVolatileInt(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 32-bit integer value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Specified by:
 
 readVolatileInt in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the int value is read.
 
 Returns:
 
 the volatile int value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readVolatileLong
```
public long readVolatileLong(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a volatile 64-bit long value from a specified offset. This operation includes a memory barrier that prevents reordering of instructions before and after it.
 
 Specified by:
 
 readVolatileLong in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the long value is read.
 
 Returns:
 
 the volatile long value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readLong
```
public long readLong()
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a 64-bit long value from the input stream.
 
 Specified by:
 
 readLong in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the 64-bit long value
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - readFloat
```
public float readFloat()
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a 32-bit floating-point number from the input stream.
 
 Specified by:
 
 readFloat in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the float value read from the stream
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - readDouble
```
public double readDouble()
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a 64-bit floating-point number from the input stream.
 
 Specified by:
 
 readDouble in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the double value read from the stream
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - readVolatileInt
```
public int readVolatileInt()
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a volatile (concurrently mutable) integer value from the input stream.
 
 Specified by:
 
 readVolatileInt in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the read integer value
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - readVolatileLong
```
public long readVolatileLong()
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads a volatile (concurrently mutable) long value from the input stream.
 
 Specified by:
 
 readVolatileLong in interface StreamingDataInput<Bytes>
 
 Returns:
 
 the read long value
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - readOffsetPositionMoved
```
protected long readOffsetPositionMoved(long adding)
 throws BufferUnderflowException,
 IllegalStateException
```
 Throws:
 
 BufferUnderflowException
 
 IllegalStateException
 - writeByte
```
@NotNull
public @NotNull Bytes writeByte(long offset,
 byte i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Writes a byte at the specified non-negative offset.
 
 Specified by:
 
 writeByte in interface RandomDataOutput<Bytes>
 
 Parameters:
 
 offset - The non-negative position within the data stream to write the byte to.
 
 i - 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.
 
 IllegalStateException - if released
 - writeShort
```
@NotNull
public @NotNull Bytes writeShort(long offset,
 short i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Writes a short integer at the specified non-negative offset.
 
 Specified by:
 
 writeShort in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeInt
```
@NotNull
public @NotNull Bytes writeInt(long offset,
 int i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Writes an integer value at the specified non-negative offset.
 
 Specified by:
 
 writeInt in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeOrderedInt
```
@NotNull
public @NotNull Bytes writeOrderedInt(long offset,
 int i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Performs a non-blocking write operation with a memory barrier to ensure order of stores. Writes an integer at the specified non-negative offset.
 
 Specified by:
 
 writeOrderedInt in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeLong
```
@NotNull
public @NotNull Bytes writeLong(long offset,
 long i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Writes a long integer value at the specified non-negative offset.
 
 Specified by:
 
 writeLong in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeOrderedLong
```
@NotNull
public @NotNull Bytes writeOrderedLong(long offset,
 long i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 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.
 
 Specified by:
 
 writeOrderedLong in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeFloat
```
@NotNull
public @NotNull Bytes writeFloat(long offset,
 float d)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Writes a single-precision floating-point value at the specified non-negative offset.
 
 Specified by:
 
 writeFloat in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeDouble
```
@NotNull
public @NotNull Bytes writeDouble(long offset,
 double d)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Writes a double-precision floating-point value at the specified non-negative offset.
 
 Specified by:
 
 writeDouble in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeVolatileByte
```
@NotNull
public @NotNull Bytes writeVolatileByte(long offset,
 byte i8)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 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.
 
 Specified by:
 
 writeVolatileByte in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeVolatileShort
```
@NotNull
public @NotNull Bytes writeVolatileShort(long offset,
 short i16)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 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.
 
 Specified by:
 
 writeVolatileShort in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeVolatileInt
```
@NotNull
public @NotNull Bytes writeVolatileInt(long offset,
 int i32)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 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.
 
 Specified by:
 
 writeVolatileInt in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - writeVolatileLong
```
@NotNull
public @NotNull Bytes writeVolatileLong(long offset,
 long i64)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 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.
 
 Specified by:
 
 writeVolatileLong in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if released
 - write
```
@NotNull
public @NotNull Bytes write(@NotNull
 @NotNull RandomDataInput bytes)
 throws IllegalStateException,
 BufferOverflowException
```
 Description copied from interface: StreamingDataOutput
 
 Writes all available data from the specified RandomDataInput into the output stream. The position of this output stream is updated accordingly, but the read position of the input data is not changed. The operation will fail if there is not enough space left in the output stream.
 
 Specified by:
 
 write in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 bytes - the RandomDataInput from which data is read.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 IllegalStateException - if released
 
 BufferOverflowException - if there is not enough space left in the output stream.
 - write
```
public Bytes write(@NotNull
 @NotNull BytesStore<?,?> bytes)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes all available data from the specified BytesStore into the output stream. The position of this output stream is updated accordingly, but the read position of the input data is not changed. The operation will fail if there is not enough space left in the output stream.
 
 Specified by:
 
 write in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 bytes - the BytesStore from which data is read.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space left in the output stream.
 
 IllegalStateException - if released
 
 See Also:
 
 StreamingDataInput.read(Bytes)
 - write
```
@NotNull
public @NotNull Bytes write(long offsetInRDO,
 byte[] byteArray,
 int offset,
 int length)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 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. writePosition()
 
 Specified by:
 
 write in interface RandomDataOutput<Bytes>
 
 Parameters:
 
 offsetInRDO - the non-negative offset within the data output where the segment should be written.
 
 byteArray - the byte array containing the segment to be written.
 
 offset - 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.
 
 IllegalStateException - if this data output has been previously released.
 - write
```
public void write(long offsetInRDO,
 @NotNull
 @NotNull ByteBuffer bytes,
 int offset,
 int length)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Copies a segment from the provided ByteBuffer into this data output.
 Does not update cursors e.g. writePosition()
 
 Specified by:
 
 write in interface RandomDataOutput<Bytes>
 
 Parameters:
 
 offsetInRDO - the non-negative offset within the data output where the segment should be written.
 
 bytes - the ByteBuffer containing the segment to be written.
 
 offset - 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.
 
 IllegalStateException - if this data output has been previously released.
 - write
```
@NotNull
public @NotNull Bytes write(long writeOffset,
 @NotNull
 @NotNull RandomDataInput bytes,
 long readOffset,
 long length)
 throws BufferOverflowException,
 BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Copies a segment from the provided RandomDataInput into this data output. This operation does not update the writePosition() of this output nor the RandomCommon.readPosition() of the input.
 
 Specified by:
 
 write in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if this data output has been previously released.
 - write8bit
```
@NotNull
public @NotNull Bytes write8bit(@NotNull
 @NotNull String text,
 int start,
 int length)
 throws BufferOverflowException,
 IndexOutOfBoundsException,
 ArithmeticException,
 IllegalStateException,
 BufferUnderflowException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a subsequence of a String as an 8-bit string to the data stream. This method is to be implemented by concrete subclasses.
 
 Specified by:
 
 write8bit in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 text - The String to be written.
 
 start - The index of the first char in the String to write.
 
 length - The number of chars from the String to write.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException
 
 IndexOutOfBoundsException
 
 ArithmeticException
 
 IllegalStateException
 
 BufferUnderflowException
 - write8bit
```
@NotNull
public @NotNull Bytes write8bit(@Nullable
 @Nullable BytesStore bs)
 throws BufferOverflowException,
 IllegalStateException,
 BufferUnderflowException
```
 Throws:
 
 BufferOverflowException
 
 IllegalStateException
 
 BufferUnderflowException
 - write8bit
```
public long write8bit(long position,
 @NotNull
 @NotNull BytesStore bs)
```
 Description copied from interface: RandomDataOutput
 
 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.
 
 Specified by:
 
 write8bit in interface RandomDataOutput<Bytes>
 
 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.
 - write8bit
```
public long write8bit(long position,
 @NotNull
 @NotNull String s,
 int start,
 int length)
```
 Description copied from interface: RandomDataOutput
 
 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.
 
 Specified by:
 
 write8bit in interface RandomDataOutput<Bytes>
 
 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.
 - writeCheckOffset
```
protected void writeCheckOffset(long offset,
 long adding)
 throws BufferOverflowException,
 IllegalStateException
```
 Throws:
 
 BufferOverflowException
 
 IllegalStateException
 - readByte
```
public byte readByte(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a byte value from a specific offset.
 
 Specified by:
 
 readByte in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the byte value is read.
 
 Returns:
 
 the read byte value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - peekUnsignedByte
```
public int peekUnsignedByte(long offset)
 throws IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads an unsigned byte value from a specific offset. Returns -1 if the byte read is at the end of the byte source. The value is returned as an int in order to represent the unsigned byte as a positive value.
 
 Specified by:
 
 peekUnsignedByte in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the unsigned byte value is read.
 
 Returns:
 
 the unsigned byte value interpreted as a positive int or -1.
 
 Throws:
 
 IllegalStateException - if the byte source has been released.
 - readShort
```
public short readShort(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a short value from a specific offset.
 
 Specified by:
 
 readShort in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the short value is read.
 
 Returns:
 
 the read short value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readInt
```
public int readInt(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a 32-bit integer value from a specific offset.
 
 Specified by:
 
 readInt in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the 32-bit integer value is read.
 
 Returns:
 
 the read int value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readLong
```
public long readLong(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a 64-bit long value from a specific offset.
 
 Specified by:
 
 readLong in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the long value is read.
 
 Returns:
 
 the read long value.
 
 Throws:
 
 BufferUnderflowException - if the offset is outside the bounds of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readFloat
```
public float readFloat(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a 32-bit floating point value from a specified offset.
 
 Specified by:
 
 readFloat in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the float value is read.
 
 Returns:
 
 the read float value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readDouble
```
public double readDouble(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a 64-bit floating point value from a specified offset.
 
 Specified by:
 
 readDouble in interface RandomDataInput
 
 Parameters:
 
 offset - the location from where the double value is read.
 
 Returns:
 
 the read double value.
 
 Throws:
 
 BufferUnderflowException - if the offset is beyond the limits of the byte source.
 
 IllegalStateException - if the byte source has been released.
 - readCheckOffset
```
protected void readCheckOffset(long offset,
 long adding,
 boolean given)
 throws BufferUnderflowException,
 IllegalStateException
```
 Throws:
 
 BufferUnderflowException
 
 IllegalStateException
 - writeByte
```
@NotNull
public @NotNull Bytes writeByte(byte i8)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a byte to the data stream.
 
 Specified by:
 
 writeByte in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i8 - The byte to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - prewrite
```
@NotNull
public @NotNull Bytes prewrite(byte[] bytes)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: BytesPrepender
 
 Writes a byte array backward in binary format. This operation moves the readPosition() backward.
 
 Specified by:
 
 prewrite in interface BytesPrepender<Bytes>
 
 Parameters:
 
 bytes - the byte array to prepend
 
 Returns:
 
 this instance, after the operation
 
 Throws:
 
 BufferOverflowException - if the capacity of the underlying buffer was exceeded
 
 IllegalStateException - if the buffer is in an invalid state
 - prewrite
```
@NotNull
public @NotNull Bytes prewrite(@NotNull
 @NotNull BytesStore bytes)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: BytesPrepender
 
 Writes a BytesStore instance backward in binary format. This operation moves the readPosition() backward.
 
 Specified by:
 
 prewrite in interface BytesPrepender<Bytes>
 
 Parameters:
 
 bytes - the BytesStore to prepend
 
 Returns:
 
 this instance, after the operation
 
 Throws:
 
 BufferOverflowException - if the capacity of the underlying buffer was exceeded
 
 IllegalStateException - if the buffer is in an invalid state
 - prewriteByte
```
@NotNull
public @NotNull Bytes prewriteByte(byte i8)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: BytesPrepender
 
 Writes a byte backward in binary format. This operation moves the readPosition() backward.
 
 Specified by:
 
 prewriteByte in interface BytesPrepender<Bytes>
 
 Parameters:
 
 i8 - the byte to prepend
 
 Returns:
 
 this instance, after the operation
 
 Throws:
 
 BufferOverflowException - if the capacity of the underlying buffer was exceeded
 
 IllegalStateException - if the buffer is in an invalid state
 - prewriteInt
```
@NotNull
public @NotNull Bytes prewriteInt(int i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: BytesPrepender
 
 Writes an int (4-byte int) backward in binary format. This operation moves the readPosition() backward.
 
 Specified by:
 
 prewriteInt in interface BytesPrepender<Bytes>
 
 Parameters:
 
 i - the int to prepend
 
 Returns:
 
 this instance, after the operation
 
 Throws:
 
 BufferOverflowException - if the capacity of the underlying buffer was exceeded
 
 IllegalStateException - if the buffer is in an invalid state
 - prewriteShort
```
@NotNull
public @NotNull Bytes prewriteShort(short i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: BytesPrepender
 
 Writes a short (2-byte int) backward in binary format. This operation moves the readPosition() backward.
 
 Specified by:
 
 prewriteShort in interface BytesPrepender<Bytes>
 
 Parameters:
 
 i - the short to prepend
 
 Returns:
 
 this instance, after the operation
 
 Throws:
 
 BufferOverflowException - if the capacity of the underlying buffer was exceeded
 
 IllegalStateException - if the buffer is in an invalid state
 - prewriteLong
```
@NotNull
public @NotNull Bytes prewriteLong(long l)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: BytesPrepender
 
 Writes a long (8-byte int) backward in binary format. This operation moves the readPosition() backward.
 
 Specified by:
 
 prewriteLong in interface BytesPrepender<Bytes>
 
 Parameters:
 
 l - the long to prepend
 
 Returns:
 
 this instance, after the operation
 
 Throws:
 
 BufferOverflowException - if the capacity of the underlying buffer was exceeded
 
 IllegalStateException - if the buffer is in an invalid state
 - writeOffsetPositionMoved
```
protected final long writeOffsetPositionMoved(long adding)
 throws BufferOverflowException,
 IllegalStateException
```
 Throws:
 
 BufferOverflowException
 
 IllegalStateException
 - writeOffsetPositionMoved
```
protected long writeOffsetPositionMoved(long adding,
 long advance)
 throws BufferOverflowException,
 IllegalStateException
```
 Throws:
 
 BufferOverflowException
 
 IllegalStateException
 - uncheckedWritePosition
```
protected void uncheckedWritePosition(long writePosition)
```
 - prewriteOffsetPositionMoved
```
protected long prewriteOffsetPositionMoved(long subtracting)
 throws BufferOverflowException,
 IllegalStateException
```
 Throws:
 
 BufferOverflowException
 
 IllegalStateException
 - writeShort
```
@NotNull
public @NotNull Bytes writeShort(short i16)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a short integer to the data stream.
 
 Specified by:
 
 writeShort in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i16 - The short integer to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - writeInt
```
@NotNull
public @NotNull Bytes writeInt(int i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes an integer to the data stream.
 
 Specified by:
 
 writeInt in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i - The integer to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - writeIntAdv
```
@NotNull
public @NotNull Bytes writeIntAdv(int i,
 int advance)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes an integer to the data stream, then advances the write position by the specified amount.
 
 Specified by:
 
 writeIntAdv in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i - The integer to be written.
 
 advance - The number of bytes to advance the write position after the integer has been written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - writeLong
```
@NotNull
public @NotNull Bytes writeLong(long i64)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a long integer to the data stream.
 
 Specified by:
 
 writeLong in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i64 - The long integer to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - writeLongAdv
```
@NotNull
public @NotNull Bytes writeLongAdv(long i64,
 int advance)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a long integer to the data stream, then advances the write position by the specified amount.
 
 Specified by:
 
 writeLongAdv in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i64 - The long integer to be written.
 
 advance - The number of bytes to advance the write position after the long integer has been written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - writeFloat
```
@NotNull
public @NotNull Bytes writeFloat(float f)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a floating-point number to the data stream.
 
 Specified by:
 
 writeFloat in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 f - The floating-point number to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - writeDouble
```
@NotNull
public @NotNull Bytes writeDouble(double d)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a double-precision floating-point number to the data stream.
 
 Specified by:
 
 writeDouble in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 d - The double-precision floating-point number to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - writeDoubleAndInt
```
@NotNull
public @NotNull Bytes writeDoubleAndInt(double d,
 int i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a double-precision floating-point number followed by an integer to the data stream.
 
 Specified by:
 
 writeDoubleAndInt in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 d - The double-precision floating-point number to be written.
 
 i - The integer to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is insufficient space in the buffer.
 
 IllegalStateException - if released
 - read
```
public int read(byte[] bytes,
 int off,
 int len)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataInput
 
 Reads the input stream into the provided byte array, starting from the given offset and reading up to the specified length.
 
 Specified by:
 
 read in interface StreamingDataInput<Bytes>
 
 Parameters:
 
 bytes - the byte array to fill with the read data
 
 off - the start offset in the byte array
 
 len - the maximum number of bytes to read
 
 Returns:
 
 the number of bytes read, or -1 if the end of the stream is reached
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to read
 
 IllegalStateException - if a required state for this operation is not met
 - read
```
public long read(long offsetInRDI,
 byte[] bytes,
 int offset,
 int length)
 throws IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Reads a sequence of bytes from the specified offset into a byte array.
 
 Specified by:
 
 read in interface RandomDataInput
 
 Parameters:
 
 offsetInRDI - the offset in the byte sequence from which to start reading.
 
 bytes - the byte array into which the data is read.
 
 offset - the start offset in the byte array at which the data is written.
 
 length - the maximum number of bytes to read.
 
 Returns:
 
 the actual number of bytes read into the byte array.
 
 Throws:
 
 IllegalStateException - if the byte sequence has been released.
 - write
```
@NotNull
public @NotNull Bytes write(byte[] byteArray,
 int offset,
 int length)
 throws BufferOverflowException,
 IllegalStateException,
 IllegalArgumentException
```
 Description copied from interface: StreamingDataOutput
 
 Writes the specified number of bytes from the given byteArray into the output stream, starting from the given offset. The position of the output stream is updated according to the number of bytes written.
 
 Specified by:
 
 write in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 byteArray - the array of bytes to be written.
 
 offset - the start index in the array from where to start writing bytes.
 
 length - the number of bytes to write.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space left in the output stream.
 
 IllegalStateException - if released
 
 IllegalArgumentException - if the provided offset or length is negative
 - safeCopySize
```
protected int safeCopySize()
```
 - writeSome
```
@NotNull
public @NotNull Bytes writeSome(@NotNull
 @NotNull ByteBuffer buffer)
 throws BufferOverflowException,
 IllegalStateException,
 BufferUnderflowException
```
 Description copied from interface: StreamingDataOutput
 
 Writes the available data from the provided ByteBuffer into this Bytes object. The number of bytes written is constrained by the space available in this Bytes object. The position of this Bytes object is updated according to the number of bytes written.
 
 Specified by:
 
 writeSome in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 buffer - the ByteBuffer from which data is read.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space left in the output stream.
 
 IllegalStateException - if the buffer is in an invalid state.
 
 BufferUnderflowException - if there is not enough data available in the input ByteBuffer.
 - writeBoolean
```
@NotNull
public @NotNull Bytes writeBoolean(boolean flag)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a boolean value to this output stream.
 
 Specified by:
 
 writeBoolean in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 flag - The boolean value to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space left in the output stream.
 
 IllegalStateException - if the buffer is in an invalid state.
 - writeOrderedInt
```
@NotNull
public @NotNull Bytes writeOrderedInt(int i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes an integer value to this output stream using an ordered-writing mechanism. Ordered writing ensures that the integer is written with a write memory barrier.
 
 Specified by:
 
 writeOrderedInt in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i - The integer value to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space left in the output stream.
 
 IllegalStateException - if the buffer is in an invalid state.
 - writeOrderedLong
```
@NotNull
public @NotNull Bytes writeOrderedLong(long i)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: StreamingDataOutput
 
 Writes a long value to this output stream using an ordered-writing mechanism. Ordered writing ensures that the integer is written with a write memory barrier.
 
 Specified by:
 
 writeOrderedLong in interface StreamingDataOutput<Bytes>
 
 Parameters:
 
 i - The long value to be written.
 
 Returns:
 
 The current StreamingDataOutput instance.
 
 Throws:
 
 BufferOverflowException - if there is not enough space left in the output stream.
 
 IllegalStateException - if the buffer is in an invalid state.
 - addressForRead
```
public long addressForRead(long offset)
 throws BufferUnderflowException,
 IllegalStateException
```
 Retrieves the underlying memory address for reading. 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:
 
 BufferUnderflowException - if the offset is before the start() or the after the capacity()
 
 IllegalStateException - if the buffer has been closed.
 - addressForWrite
```
public long addressForWrite(long offset)
 throws BufferOverflowException,
 IllegalStateException
```
 Retrieves the underlying memory address for writing. 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:
 
 BufferOverflowException - if the offset is before the start() or the after the capacity()
 
 IllegalStateException
 - addressForWritePosition
```
public long addressForWritePosition()
 throws BufferOverflowException,
 IllegalStateException
```
 Retrieves the underlying memory address for writing at the current write position. This is for expert users only.
 
 Returns:
 
 The underlying memory address for writing at the current write position.
 
 Throws:
 
 BufferOverflowException - if the current write position is before the start or after the capacity.
 
 IllegalStateException - if the buffer state doesn't allow the operation.
 - hashCode
```
public int hashCode()
```
 Overrides:
 
 hashCode in class Object
 - equals
```
public boolean equals(Object obj)
```
 Overrides:
 
 equals in class Object
 - toString
```
@NotNull
public @NotNull String toString()
```
 Specified by:
 
 toString in interface CharSequence
 
 Overrides:
 
 toString in class net.openhft.chronicle.core.io.AbstractReferenceCounted
 - nativeRead
```
public void nativeRead(long position,
 long address,
 long size)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Expert-level method for transferring data from this byte source to native memory.
 
 Specified by:
 
 nativeRead in interface RandomDataInput
 
 Parameters:
 
 position - the starting point within the byte source from which data is copied.
 
 address - the destination address in native memory.
 
 size - the number of bytes to transfer.
 
 Throws:
 
 BufferUnderflowException - if the specified position or size exceeds the byte source limits.
 
 IllegalStateException - if the byte source has been released.
 - nativeWrite
```
public void nativeWrite(long address,
 long position,
 long size)
 throws BufferOverflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataOutput
 
 Expert-level method that copies data directly from native memory into this BytesStore.
 
 Specified by:
 
 nativeWrite in interface RandomDataOutput<Bytes>
 
 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.
 
 IllegalStateException - if this BytesStore has been previously released.
 - bytesStore
```
@NotNull
public @NotNull BytesStore bytesStore()
```
 Description copied from interface: Bytes
 
 Returns the backing BytesStore that this Bytes object wraps. If this Bytes object doesn't have a backing BytesStore, this method returns null.
 The BytesStore represents the underlying storage of bytes that the Bytes object is manipulating.
 
 Specified by:
 
 bytesStore in interface Bytes
 
 Specified by:
 
 bytesStore in interface BytesStore<Bytes,U>
 
 Returns:
 
 The backing BytesStore, or null if there isn't one.
 - bytesStore
```
protected void bytesStore(BytesStore<Bytes,U> bytesStore)
```
 - lastDecimalPlaces
```
public int lastDecimalPlaces()
```
 Description copied from interface: ByteStringParser
 
 Returns the number of decimal places in the last parsed floating-point number (from the ByteStringParser.parseDouble() or ByteStringParser.parseLongDecimal() methods).
 
 Specified by:
 
 lastDecimalPlaces in interface ByteStringParser<Bytes>
 
 Returns:
 
 the number of decimal places in the last parsed number.
 - lastDecimalPlaces
```
public void lastDecimalPlaces(int lastDecimalPlaces)
```
 Description copied from interface: ByteStringParser
 
 Sets the number of decimal places in the last parsed number. If the given value is positive, it is directly set; otherwise, the decimal place count is set to 0.
 
 Specified by:
 
 lastDecimalPlaces in interface ByteStringParser<Bytes>
 
 Parameters:
 
 lastDecimalPlaces - the number of decimal places to set, if positive; otherwise 0.
 - lastNumberHadDigits
```
public boolean lastNumberHadDigits()
```
 Description copied from interface: ByteStringParser
 
 Returns whether the last parsed number had any digits.
 
 Specified by:
 
 lastNumberHadDigits in interface ByteStringParser<Bytes>
 
 Returns:
 
 true if the last parsed number had digits, false otherwise.
 - lastNumberHadDigits
```
public void lastNumberHadDigits(boolean lastNumberHadDigits)
```
 Description copied from interface: ByteStringParser
 
 Sets whether the last parsed number had any digits.
 
 Specified by:
 
 lastNumberHadDigits in interface ByteStringParser<Bytes>
 
 Parameters:
 
 lastNumberHadDigits - the new value to set, true if the last parsed number had digits, false otherwise.
 - copy
```
public BytesStore<Bytes,U> copy()
 throws IllegalStateException
```
 Description copied from interface: Bytes
 
 Creates and returns a deep copy of this Bytes object, including the data between RandomCommon.readPosition() and RandomCommon.readLimit().
 The copy will have its own separate storage and state, and modifications to the copy will not affect the original Bytes object, and vice versa.
 
 Specified by:
 
 copy in interface Bytes
 
 Specified by:
 
 copy in interface BytesStore<Bytes,U>
 
 Returns:
 
 A new Bytes object that is a copy of this object.
 
 Throws:
 
 IllegalStateException - If this Bytes object is in an illegal state for copying.
 - isElastic
```
public boolean isElastic()
```
 Description copied from interface: Bytes
 
 Checks if this Bytes object is elastic, meaning it can dynamically resize when more data is written than its current Bytes.realCapacity().
 Elastic Bytes objects can automatically grow to accommodate additional data, whereas non-elastic ones have a fixed capacity.
 
 Specified by:
 
 isElastic in interface Bytes
 
 Returns:
 
 true if this Bytes object is elastic; false otherwise.
 - lenient
```
public void lenient(boolean lenient)
```
 Description copied from interface: StreamingDataInput
 
 When there is no more data to read, return zero, false and empty string.
 
 Specified by:
 
 lenient in interface StreamingDataInput<Bytes>
 
 Parameters:
 
 lenient - if true, return nothing rather than error.
 - lenient
```
public boolean lenient()
```
 Specified by:
 
 lenient in interface StreamingDataInput<Bytes>
 - byteCheckSum
```
public int byteCheckSum()
 throws net.openhft.chronicle.core.io.IORuntimeException,
 BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: BytesStore
 
 Returns the bytes sum of the readable bytes in this BytesStore.
 
 Specified by:
 
 byteCheckSum in interface BytesStore<Bytes,U>
 
 Returns:
 
 unsigned bytes sum
 
 Throws:
 
 BufferUnderflowException - if there's not enough data to be moved
 
 IllegalStateException - if the BytesStore has been released
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - if this Bytes has been released
 
 net.openhft.chronicle.core.io.IORuntimeException
 - byteCheckSum
```
public int byteCheckSum(long start,
 long end)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: BytesStore
 
 Returns the bytes sum between the specified indexes; start (inclusive) and end (exclusive).
 
 Specified by:
 
 byteCheckSum in interface BytesStore<Bytes,U>
 
 Parameters:
 
 start - the index of the first byte to sum
 
 end - the index of the last byte to sum
 
 Returns:
 
 unsigned bytes sum
 
 Throws:
 
 BufferUnderflowException - if the specified indexes are outside the limits of the BytesStore
 
 IllegalStateException - if the BytesStore has been released
 - startsWith
```
public boolean startsWith(@Nullable
 @Nullable BytesStore bytesStore)
 throws IllegalStateException
```
 Description copied from interface: BytesStore
 
 Returns if the content of this BytesStore starts with bytes equal to the content of a specified BytesStore.
 
 Specified by:
 
 startsWith in interface BytesStore<Bytes,U>
 
 Parameters:
 
 bytesStore - the BytesStore to compare with
 
 Returns:
 
 true if the content of this BytesStore starts with bytesStore
 
 Throws:
 
 net.openhft.chronicle.core.io.ClosedIllegalStateException - if this Bytes has been released
 
 IllegalStateException - if this Bytes is in an unusable state
 - acquireUncheckedInput
```
@NotNull
public @NotNull UncheckedRandomDataInput acquireUncheckedInput()
```
 Description copied from interface: HasUncheckedRandomDataInput
 
 Returns a view of a memory segment providing memory read operations with potentially unchecked memory boundaries.
 
 Specified by:
 
 acquireUncheckedInput in interface HasUncheckedRandomDataInput
 
 Returns:
 
 an unchecked view
 - byteCheckSum
```
public int byteCheckSum(int start,
 int end)
 throws BufferUnderflowException,
 IllegalStateException
```
 Returns the bytes sum between the specified indexes; start (inclusive) and end (exclusive).
 
 Parameters:
 
 start - the index of the first byte to sum
 
 end - the index of the last byte to sum
 
 Returns:
 
 unsigned bytes sum
 
 Throws:
 
 BufferUnderflowException - if the specified indexes are outside the limits of the BytesStore
 
 IllegalStateException - if the BytesStore has been released
 - isImmutableEmptyByteStore
```
public boolean isImmutableEmptyByteStore()
```
 Description copied from interface: BytesStore
 
 Returns if this ByteStore is an immutable empty ByteStore or if it is backed by an immutable empty ByteStore.
 
 Specified by:
 
 isImmutableEmptyByteStore in interface BytesStore<Bytes,U>
 
 Returns:
 
 if immutable empty or backed by such
 - copyTo
```
public int copyTo(byte[] bytes)
 throws BufferUnderflowException,
 IllegalStateException
```
 Description copied from interface: RandomDataInput
 
 Copies data from this byte source into a byte array. The data is read from RandomCommon.readPosition() up to RandomCommon.readLimit().
 
 Specified by:
 
 copyTo in interface RandomDataInput
 
 Parameters:
 
 bytes - the target byte array to which the data is copied.
 
 Returns:
 
 the number of bytes actually copied.
 
 Throws:
 
 BufferUnderflowException - if the source's read position or limit is beyond the byte source limits.
 
 IllegalStateException - if the byte source has been released.
 - internalNumberBuffer
```
@Deprecated
public byte[] internalNumberBuffer()
```
 Deprecated.
 
 Specified by:
 
 internalNumberBuffer in interface ByteStringAppender<Bytes>
 
 Specified by:
 
 internalNumberBuffer in interface RandomDataOutput<Bytes>
 
 Specified by:
 
 internalNumberBuffer in interface StreamingDataOutput<Bytes>

Class AbstractBytes<U>

Field Summary

Fields inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted

Fields inherited from interface net.openhft.chronicle.bytes.Bytes

Fields inherited from interface net.openhft.chronicle.bytes.RandomDataInput

Fields inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput

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

Method Summary

Methods inherited from class net.openhft.chronicle.core.io.AbstractReferenceCounted

Methods inherited from class java.lang.Object

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

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

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

Methods inherited from interface java.lang.CharSequence

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

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

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

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

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

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

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

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

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

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

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

Field Detail

DISABLE_THREAD_SAFETY

bytesStore

readPosition

writeLimit

isPresent

Method Detail

isDirectMemory

canReadDirect

move

compact

clear

clearAndPad

readLimit

writeLimit

realCapacity

canWriteDirect

capacity

underlyingObject

length

start

readPosition

writePosition

compareAndSwapInt

testAndSetInt

compareAndSwapLong

append

append

append

append

decimaliser

decimaliser

fpAppend0

fpAppend0

append

appendAndReturnLength

append

readPosition

readLimit

writePosition

readSkip

readPositionForHeader

uncheckedReadSkipOne

uncheckedReadSkipBackOne

writeSkip

writeLimit

performRelease

readUnsignedByte

readUnsignedByte

uncheckedReadUnsignedByte

readByte

peekUnsignedByte

readShort

readInt

readVolatileByte