HexDumpBytes (OpenHFT/Chronicle Bytes 2.25ea2 API)

java.lang.Object
- net.openhft.chronicle.bytes.HexDumpBytes

All Implemented Interfaces:

Appendable, CharSequence, Bytes<Void>, BytesIn<Void>, BytesOut<Void>, BytesPrepender<Bytes<Void>>, BytesStore<Bytes<Void>,Void>, ByteStringAppender<Bytes<Void>>, ByteStringParser<Bytes<Void>>, HexDumpBytesDescription<BytesOut<Void>>, RandomDataInput, RandomDataOutput<Bytes<Void>>, DecimalAppender, StreamingCommon<Bytes<Void>>, StreamingDataInput<Bytes<Void>>, StreamingDataOutput<Bytes<Void>>, net.openhft.chronicle.core.io.ReferenceCounted, net.openhft.chronicle.core.io.ReferenceOwner, net.openhft.chronicle.core.io.SingleThreadedChecked
```
public class HexDumpBytes
extends Object
implements Bytes<Void>, DecimalAppender
```
A class that implements the Bytes interface for generating a hex dump of byte data. The hex dump is a human-readable display of data in hexadecimal and ASCII formats. It's commonly used for debugging, forensics, and analyzing low-level data.
It supports setting specific number wrap for byte data and custom offset formatting to provide more flexibility and control over the output of the hex dump. The class also enables indentation adjustment, which can be useful for nested data structures or logically grouped data within the byte array.

Field Summary

Fields
Modifier and Type Field and Description

static long MASK
- 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.StreamingDataOutput
  JAVA9_STRING_CODER_LATIN, JAVA9_STRING_CODER_UTF16
- Fields inherited from interface net.openhft.chronicle.core.io.SingleThreadedChecked
  DISABLE_SINGLE_THREADED_CHECK

Fields
Modifier and Type	Field and Description
`static long`	`MASK`

Constructor Summary

Constructors
Constructor and Description

HexDumpBytes()
Constructs a HexDumpBytes instance with default settings.

Constructors
Constructor and Description
`HexDumpBytes()` Constructs a HexDumpBytes instance with default settings.

Method Summary

All Methods Static Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`addReferenceChangeListener(net.openhft.chronicle.core.io.ReferenceChangeListener referenceChangeListener)`
`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.
`BytesOut<Void>`	`adjustHexDumpIndentation(int n)` Adjust the indent for nested data
`@NotNull Bytes<Void>`	`append(@NotNull BigDecimal bigDecimal)` Appends a string representation of a specified BigDecimal to this.
`@NotNull Bytes<Void>`	`append(boolean flag)` Appends a boolean as 'T' or 'F' character.
`void`	`append(boolean isNegative, long mantissa, int exponent)` Appends a decimal number, represented by its sign, mantissa, and exponent, to a target.
`@NotNull Bytes<Void>`	`append(char ch)` Appends a UTF-8 encoded character to the buffer.
`@NotNull Bytes<Void>`	`append(@NotNull CharSequence cs)` Append a characters in UTF-8
`@NotNull Bytes<Void>`	`append(@NotNull CharSequence cs, int start, int end)` Appends a portion of a string to the Bytes in UTF-8.
`@NotNull Bytes<Void>`	`append(double d)` Appends a double in decimal notation
`@NotNull Bytes<Void>`	`append(double d, int decimalPlaces)` Appends a double in decimal notation to a specific number of decimal places.
`@NotNull Bytes<Void>`	`append(float f)` Appends a float in decimal notation
`@NotNull Bytes<Void>`	`append(int value)` Appends an int in decimal to this.
`@NotNull Bytes<Void>`	`append(long value)` Appends a long value in decimal.
`Bytes<Void>`	`append8bit(@NotNull BytesStore bs)` Appends the ISO-8859-1 representation of the specified BytesStore.
`Bytes<Void>`	`append8bit(@NotNull BytesStore bs, long start, long end)` Appends a portion of a BytesStore to this in ISO-8859-1 format.
`@NotNull Bytes<Void>`	`append8bit(@NotNull CharSequence cs)` Appends a String to the Bytes in ISO-8859-1.
`Bytes<Void>`	`append8bit(@NotNull CharSequence cs, int start, int end)` Appends a portion of a string to this Bytes in ISO-8859-1.
`Bytes<Void>`	`append8bit(@NotNull String cs)` Appends the ISO-8859-1 representation of the specified String.
`long`	`appendAndReturnLength(long writePosition, boolean negative, long mantissa, int exponent, boolean append0)`
`@NotNull Bytes<Void>`	`appendBase(long value, int base)` Appends a string representation of the first argument in the radix specified by the second argument.
`@NotNull Bytes<Void>`	`appendBase16(long value)` Appends the base 16 (hexadecimal) representation of the specified long value.
`@NotNull Bytes<Void>`	`appendBase16(long value, int minDigits)` Appends the base 16 (hexadecimal) representation of the specified long value, padding with leading zeroes if the number of digits is less than minDigits.
`@NotNull Bytes<Void>`	`appendDateMillis(long dateInMillis)` Converts a specified long number to a date in the format yyyymmdd and appends the date to this.
`@NotNull Bytes<Void>`	`appendDecimal(long value, int decimalPlaces)` Appends a long in decimal with a given number of decimal places.
`@NotNull Bytes<Void>`	`appendTimeMillis(long timeOfDayInMillis)` Converts a specified long number to time of day and appends it to this.
`@NotNull BytesStore`	`bytesStore()` Returns the backing BytesStore that this Bytes object wraps.
`long`	`capacity()` Provides the maximum limit that can be set for the ByteStore.
`@NotNull Bytes<Void>`	`clear()` Clears the content of this Bytes object and resets its state.
`@NotNull Bytes<Void>`	`clearAndPad(long length)` Clears the buffer and pads it with a specified length to allow prepending later.
`@NotNull Bytes<Void>`	`compact()` Compacts this Bytes object by moving the readPosition() to the start(), adjusting the readLimit()/writePosition() appropriately so that the readRemaining() is unchanged.
`boolean`	`compareAndSwapInt(long offset, int expected, int value)` Performs a 32-bit compare-and-swap (CAS) operation at a given offset.
`boolean`	`compareAndSwapLong(long offset, long expected, long value)` Performs a 64-bit compare-and-swap (CAS) operation at a given offset.
`BytesStore`	`copy()` Creates and returns a deep copy of this Bytes object, including the data between `RandomCommon.readPosition()` and `RandomCommon.readLimit()`.
`Decimaliser`	`decimaliser()` Gets the Decimaliser currently associated with this ByteStringAppender.
`Bytes<Void>`	`decimaliser(Decimaliser decimaliser)` Associates a Decimaliser with this ByteStringAppender.
`void`	`ensureCapacity(long desiredCapacity)` Ensures that this Bytes object has the capacity to accommodate the specified amount of data.
`boolean`	`equals(Object obj)`
`boolean`	`fpAppend0()`
`Bytes<Void>`	`fpAppend0(boolean append0)`
`static HexDumpBytes`	`fromText(@NotNull CharSequence text)` Creates a HexDumpBytes instance from provided char sequence.
`static HexDumpBytes`	`fromText(@NotNull Reader reader)` Creates a HexDumpBytes instance from provided text reader.
`int`	`hashCode()`
`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()`.
`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.
`long`	`lengthWritten(long startPosition)` Calculates the length of data written from the given start position.
`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`	`numberWrap()` Retrieves the current number wrap setting.
`HexDumpBytes`	`numberWrap(int numberWrap)` Sets the number wrap for the hex dump.
`HexDumpBytes`	`offsetFormat(OffsetFormat offsetFormat)` Sets the offset format for the hex dump.
`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.
`@NotNull Bytes<Void>`	`prewrite(byte[] bytes)` Writes a byte array backward in binary format.
`@NotNull Bytes<Void>`	`prewrite(BytesStore bytes)` Writes a BytesStore instance backward in binary format.
`@NotNull Bytes<Void>`	`prewriteByte(byte b)` Writes a byte backward in binary format.
`@NotNull Bytes<Void>`	`prewriteInt(int i)` Writes an int (4-byte int) backward in binary format.
`@NotNull Bytes<Void>`	`prewriteLong(long l)` Writes a long (8-byte int) backward in binary format.
`@NotNull Bytes<Void>`	`prewriteShort(short i)` Writes a short (2-byte int) backward in binary format.
`int`	`read(byte[] bytes)` Reads the input stream into the provided byte array.
`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.
`void`	`read(@NotNull ByteBuffer buffer)` Reads the input stream into the provided ByteBuffer.
`void`	`read(@NotNull Bytes<?> bytes, int length)` Transfers the specified number of bytes from the input stream into the provided Bytes object.
`int`	`read(char[] bytes, int off, int len)` Reads the input stream into the provided char array, starting from the given offset and reading up to the specified length.
`@Nullable String`	`read8bit()` Reads an 8-bit encoded string from the input stream.
`boolean`	`read8bit(@NotNull Bytes<?> b)` Reads an 8-bit encoded string from the input stream and appends it to the provided Bytes.
`boolean`	`read8bit(@NotNull StringBuilder sb)` Reads an 8-bit encoded string from the input stream and appends it to the provided StringBuilder.
`@NotNull BigDecimal`	`readBigDecimal()` Creates and returns a new BigDecimal representing the contents of this Bytes object.
`@NotNull BigInteger`	`readBigInteger()` Creates and returns a new BigInteger representing the contents of this Bytes object or `BigInteger.ZERO` if this Bytes object is empty.
`boolean`	`readBoolean()` Reads a boolean value from the input stream.
`byte`	`readByte()` Reads a byte value from the input stream.
`byte`	`readByte(long offset)` Reads a byte value from a specific offset.
`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.
`<E extends Enum<E>> E`	`readEnum(@NotNull Class<E> eClass)` Reads an Enum value from the input stream.
`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.
`void`	`readHistogram(@NotNull net.openhft.chronicle.core.util.Histogram histogram)` Reads data from the input stream into the provided Histogram.
`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.
`int`	`readInt24()` Reads a 24-bit signed integer value from the input stream.
`long`	`readLimit()` If the resource is closed, the returned value is unspecified.
`@NotNull Bytes<Void>`	`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.
`<T extends ReadBytesMarshallable> T`	`readMarshallableLength16(@NotNull Class<T> clazz, T using)` Reads the content of this Bytes object and converts it into an instance of the specified class.
`long`	`readPosition()` Returns the read position.
`@NotNull Bytes<Void>`	`readPosition(long position)` Sets the read position of this StreamingDataInput.
`@NotNull Bytes<Void>`	`readPositionRemaining(long position, long remaining)` Sets the read position and limit of this StreamingDataInput based on the specified position and remaining values.
`@NotNull Bytes<Void>`	`readPositionUnlimited(long position)` Sets the read position of this StreamingDataInput without limiting it to the current read limit.
`long`	`readRemaining()` Calculates the number of bytes remaining that can be read from the current read position.
`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<Void>`	`readSkip(long bytesToSkip)` Skips the specified number of bytes by advancing the read position.
`long`	`readStopBit()` Reads a variable-length integer encoded using the stop bit encoding.
`char`	`readStopBitChar()` Reads a variable-length character encoded using the stop bit encoding.
`double`	`readStopBitDecimal()` Reads a decimal number represented as a variable-length double and scale encoded using the stop bit encoding.
`double`	`readStopBitDouble()` Reads a variable-length double encoded using the stop bit encoding.
`int`	`readUnsignedByte()` Reads the next unsigned 8-bit value from the input stream.
`long`	`readUnsignedInt()` Reads a 32-bit value from the input stream and converts it to an unsigned integer by masking the sign bit.
`int`	`readUnsignedInt24()` Reads a 24-bit unsigned integer value from the input stream.
`int`	`readUnsignedShort()` Reads a 16-bit value from the input stream and converts it to an unsigned short by masking the sign bit.
`@Nullable String`	`readUtf8()` Reads a UTF-8 encoded string from the input stream.
`<C extends Appendable & CharSequence> boolean`	`readUtf8(C sb)` Reads a UTF-8 encoded string from the input stream and appends it to the provided appendable.
`<C extends Appendable & CharSequence> long`	`readUtf8(long offset, C sb)` Truncates `sb` (it must be a `StringBuilder` or `Bytes`) and reads a char sequence from the given `offset`, encoded as Utf8, into it.
`<C extends Appendable & CharSequence> long`	`readUtf8Limited(long offset, C sb, int maxUtf8Len)` Truncates `sb` (it must be a `StringBuilder` or `Bytes`) and reads a char sequence from the given `offset`, encoded as Utf8, into it.
`@Nullable String`	`readUtf8Limited(long offset, int maxUtf8Len)` Reads a char sequence from the given `offset`, encoded as Utf8.
`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.
`void`	`readWithLength(@NotNull Bytes<?> bytes)` Reads data from the input stream with specified length into the provided Bytes.
`void`	`readWithLength(long length, @NotNull BytesOut<Void> bytesOut)` Writes the specified number of bytes from this Bytes object into the provided `bytesOut`.
`void`	`readWithLength(long length, @NotNull net.openhft.chronicle.core.util.ThrowingConsumer<Bytes<Void>,net.openhft.chronicle.core.io.IORuntimeException> bytesConsumer)` Perform a set of actions within a temporary bounds mode.
`void`	`readWithLength0(long length, @NotNull net.openhft.chronicle.core.util.ThrowingConsumerNonCapturing<Bytes<Void>,net.openhft.chronicle.core.io.IORuntimeException,BytesOut> bytesConsumer, StringBuilder sb, BytesOut<?> toBytes)` Perform a set of actions within a temporary bounds mode.
`int`	`refCount()`
`void`	`release(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`void`	`releaseLast(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`void`	`removeReferenceChangeListener(net.openhft.chronicle.core.io.ReferenceChangeListener referenceChangeListener)`
`void`	`reserve(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`boolean`	`retainedHexDumpDescription()` Do these Bytes support saving comments as descriptions for fields.
`void`	`singleThreadedCheckDisabled(boolean singleThreadedCheckDisabled)`
`void`	`singleThreadedCheckReset()`
`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`	`toHexString()` Creates and returns a new String representing the contents of this Bytes object in hexadecimal form, with comments describing the meaning of the bytes.
`@NotNull String`	`toString()`
`boolean`	`tryReserve(net.openhft.chronicle.core.io.ReferenceOwner owner)`
`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.
`@Nullable Void`	`underlyingObject()`
`@NotNull Bytes<Void>`	`write(byte[] byteArray)` Writes all the bytes from the given `byteArray` into the output stream.
`@NotNull Bytes<Void>`	`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<Void>`	`write(@NotNull BytesStore<?,?> bytes)` Writes all available data from the specified `BytesStore` into the output stream.
`@NotNull Bytes<Void>`	`write(@NotNull BytesStore bytes, long offset, long length)` Writes the specified number of bytes from the provided `BytesStore` into the output stream, starting from the given read offset.
`@NotNull Bytes<Void>`	`write(@NotNull CharSequence text)` Writes the provided `text` to this StreamingDataOutput at the current writePosition().
`@NotNull Bytes<Void>`	`write(@NotNull CharSequence text, int startText, int length)` Writes the provided `text` to this StreamingDataOutput at the current writePosition()
`Bytes<?>`	`write(@NotNull InputStream inputStream)` Writes the contents of the provided `inputStream` into this Bytes object.
`@NotNull Bytes<Void>`	`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<Void>`	`write(long writeOffset, @NotNull RandomDataInput bytes, long readOffset, long length)` Copies a segment from the provided RandomDataInput into this data output.
`@NotNull Bytes<Void>`	`write(@NotNull RandomDataInput bytes)` Writes all available data from the specified `RandomDataInput` into the output stream.
`@NotNull Bytes<Void>`	`write(@NotNull RandomDataInput bytes, long offset, long length)` Writes the specified number of bytes from the provided `RandomDataInput` object into the output stream, starting from the given read offset.
`@NotNull Bytes<Void>`	`write8bit(@Nullable CharSequence text)` Writes a CharSequence as an 8-bit string to the data stream.
`@NotNull Bytes<Void>`	`write8bit(@NotNull CharSequence text, int start, int length)` Writes a subsequence of a CharSequence as an 8-bit string to the data stream.
`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<Void>`	`write8bit(@Nullable String s)` Writes a String as an 8-bit string to the data stream.
`@NotNull Bytes<Void>`	`write8bit(@NotNull String text, int start, int length)` Writes a subsequence of a String as an 8-bit string to the data stream.
`void`	`writeBigDecimal(@NotNull BigDecimal bd)` Writes the given BigDecimal into this Bytes object.
`void`	`writeBigInteger(@NotNull BigInteger bi)` Writes the given BigInteger into this Bytes object.
`@NotNull Bytes<Void>`	`writeBoolean(boolean flag)` Writes a boolean value to this output stream.
`@NotNull Bytes<Void>`	`writeByte(byte i8)` Writes a byte to the data stream.
`@NotNull Bytes<Void>`	`writeByte(long offset, byte i8)` Writes a byte at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeDouble(double d)` Writes a double-precision floating-point number to the data stream.
`@NotNull Bytes<Void>`	`writeDouble(long offset, double d)` Writes a double-precision floating-point value at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeDoubleAndInt(double d, int i)` Writes a double-precision floating-point number followed by an integer to the data stream.
`<E extends Enum<E>> Bytes<Void>`	`writeEnum(E e)` Writes an enum value to this output stream by writing the enum's name.
`@NotNull Bytes<Void>`	`writeFloat(float f)` Writes a floating-point number to the data stream.
`@NotNull Bytes<Void>`	`writeFloat(long offset, float d)` Writes a single-precision floating-point value at the specified non-negative offset.
`Bytes<Void>`	`writeHexDumpDescription(@NotNull CharSequence comment)` Add comment as appropriate for the toHexString format
`void`	`writeHistogram(@NotNull net.openhft.chronicle.core.util.Histogram histogram)` Writes the given Histogram object into this Bytes object.
`@NotNull Bytes<Void>`	`writeInt(int i)` Writes an integer to the data stream.
`@NotNull Bytes<Void>`	`writeInt(long offset, int i)` Writes an integer value at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeInt24(int i)` Writes a 24-bit integer to the data stream.
`@NotNull Bytes<Void>`	`writeInt24(long offset, int i)` Writes a 24-bit integer at the specified non-negative offset.
`@NotNull Bytes<Void>`	`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<Void>`	`writeLimit(long limit)` Sets the limit for writing to the data stream.
`@NotNull Bytes<Void>`	`writeLong(long i64)` Writes a long integer to the data stream.
`@NotNull Bytes<Void>`	`writeLong(long offset, long i)` Writes a long integer value at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeLongAdv(long i64, int advance)` Writes a long integer to the data stream, then advances the write position by the specified amount.
`void`	`writeMarshallableLength16(@NotNull WriteBytesMarshallable marshallable)` Writes the content of the provided `marshallable` into this Bytes object, including a 16-bit length indicator preceding the actual object data.
`@NotNull Bytes<Void>`	`writeOrderedInt(int i)` Writes an integer value to this output stream using an ordered-writing mechanism.
`@NotNull Bytes<Void>`	`writeOrderedInt(long offset, int i)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`@NotNull Bytes<Void>`	`writeOrderedLong(long i)` Writes a long value to this output stream using an ordered-writing mechanism.
`@NotNull Bytes<Void>`	`writeOrderedLong(long offset, long i)` Performs a non-blocking write operation with a memory barrier to ensure order of stores.
`long`	`writePosition()` For HexDumpBytes it needs to remember the writePosition for the underlying bytes as well as the text hex dump, so it encodes both in one number so you can call writePosition later.
`@NotNull Bytes<Void>`	`writePosition(long position)` Sets the current write position in the data stream.
`void`	`writePositionRemaining(long position, long length)` Sets the write position and the remaining length of writable bytes in this Bytes object.
`long`	`writeRemaining()` Calculates the number of bytes remaining that can be written from the current write position.
`@NotNull Bytes<Void>`	`writeShort(long offset, short i)` Writes a short integer at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeShort(short i16)` Writes a short integer to the data stream.
`@NotNull Bytes<Void>`	`writeSkip(long bytesToSkip)` Skips a specified number of bytes from the current write position in the data stream.
`@NotNull Bytes<Void>`	`writeSome(@NotNull ByteBuffer buffer)` Writes the available data from the provided `ByteBuffer` into this Bytes object.
`@NotNull Bytes<Void>`	`writeStopBit(char x)` Writes a stop bit encoded char to the data stream.
`@NotNull Bytes<Void>`	`writeStopBit(double d)` Writes a stop bit encoded double value to the data stream.
`@NotNull Bytes<Void>`	`writeStopBit(long x)` Writes a stop bit encoded long to the data stream.
`@NotNull Bytes<Void>`	`writeStopBitDecimal(double d)` Writes a double value to the data stream with a stop bit encoded decimal.
`@NotNull Bytes<Void>`	`writeUnsignedByte(int i)` Writes an unsigned byte to the data stream.
`@NotNull Bytes<Void>`	`writeUnsignedInt(long i)` Writes an unsigned integer to the data stream.
`@NotNull Bytes<Void>`	`writeUnsignedInt24(int i)` Writes an unsigned 24-bit integer to the data stream.
`@NotNull Bytes<Void>`	`writeUnsignedShort(int u16)` Writes an unsigned short integer to the data stream.
`@NotNull Bytes<Void>`	`writeUtf8(@Nullable CharSequence text)` Writes a UTF-8 encoded string to the data stream, similar to writeUTF, but with a few differences.
`@NotNull Bytes<Void>`	`writeUtf8(@Nullable String text)` Writes a UTF-8 encoded String to the data stream.
`@NotNull Bytes<Void>`	`writeVolatileByte(long offset, byte i8)` Writes a volatile byte at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeVolatileInt(long offset, int i32)` Writes a volatile integer at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeVolatileLong(long offset, long i64)` Writes a volatile long integer at the specified non-negative offset.
`@NotNull Bytes<Void>`	`writeVolatileShort(long offset, short i16)` Writes a volatile short at the specified non-negative offset.
`void`	`writeWithLength(@NotNull RandomDataInput bytes)` Writes data from the provided RandomDataInput into this Bytes object with prefixed length.
`@NotNull Bytes<Void>`	`zeroOut(long start, long end)` Fills the BytesStore with zeros.

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, forFieldGroup, from, from, fromDirect, fromHexString, indexOf, indexOf, isClear, isEqual, readWrite, realCapacity, safeLimit, sharedMemory, toHexString, toHexString, toString, toString, toString, unchecked, unchecked, unwrite, valueOf, wrapForRead, wrapForRead, wrapForWrite, wrapForWrite

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

Methods inherited from interface net.openhft.chronicle.bytes.RandomDataOutput
append, append, write, write, writeBoolean, writeByte, 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, canReadDirect, compareUtf8, copyTo, copyTo, fastHash, findByte, parseLong, peekVolatileInt, printable, read, readBoolean, readIncompleteLong, readUnsignedByte, readUnsignedInt, readUnsignedInt24, readUnsignedShort, 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, readChar, readIncompleteLong, readLimitToCapacity, readPositionForHeader, readUtf8, readUtf8, unsafeRead, unsafeReadObject, unsafeReadObject

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

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

Methods inherited from interface net.openhft.chronicle.bytes.StreamingDataOutput
appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, appendUtf8, canWriteDirect, copyFrom, outputStream, rawWriteByte, rawWriteInt, rawWriteLong, unsafeWrite, unsafeWriteObject, unsafeWriteObject, writeChar, writePositionForHeader

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

- Field Detail
  - MASK
```
public static final long MASK
```
    See Also:
    
    Constant Field Values
- Constructor Detail
  - HexDumpBytes
```
public HexDumpBytes()
```
    Constructs a HexDumpBytes instance with default settings.
- Method Detail
  - fromText
```
public static HexDumpBytes fromText(@NotNull
                                    @NotNull Reader reader)
                             throws NumberFormatException
```
    Creates a HexDumpBytes instance from provided text reader.
    
    Parameters:
    
    reader - Reader instance to read the text data.
    
    Returns:
    
    HexDumpBytes instance initialized with the read text data.
    
    Throws:
    
    NumberFormatException - if parsing a number fails.
  - fromText
```
public static HexDumpBytes fromText(@NotNull
                                    @NotNull CharSequence text)
                             throws NumberFormatException
```
    Creates a HexDumpBytes instance from provided char sequence.
    
    Parameters:
    
    text - CharSequence to read the text data from.
    
    Returns:
    
    HexDumpBytes instance initialized with the read text data.
    
    Throws:
    
    NumberFormatException - if parsing a number fails.
  - offsetFormat
```
public HexDumpBytes offsetFormat(OffsetFormat offsetFormat)
```
    Sets the offset format for the hex dump.
    
    Parameters:
    
    offsetFormat - The offset format to use.
    
    Returns:
    
    The HexDumpBytes instance, for chaining.
  - numberWrap
```
public int numberWrap()
```
    Retrieves the current number wrap setting.
    
    Returns:
    
    The current number wrap.
  - numberWrap
```
public HexDumpBytes numberWrap(int numberWrap)
```
    Sets the number wrap for the hex dump.
    
    Parameters:
    
    numberWrap - The number wrap to use.
    
    Returns:
    
    The HexDumpBytes instance, for chaining.
  - readRemaining
```
public long readRemaining()
```
    Calculates the number of bytes remaining that can be read from the current read position.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can still be read.
  - writeRemaining
```
public long writeRemaining()
```
    Calculates the number of bytes remaining that can be written from the current write position.
    If the resource is closed, the returned value is unspecified.
    
    Returns:
    
    The number of bytes that can still be written.
  - 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
  - toHexString
```
@NotNull
public @NotNull String toHexString()
```
    Description copied from interface: Bytes
    Creates and returns a new String representing the contents of this Bytes object in hexadecimal form, with comments describing the meaning of the bytes. The representation starts at the readPosition() and encodes at most 1024 bytes.
    Each line of the output string contains hexadecimal representation of 16 bytes, followed by comments describing the meaning of those bytes.
    For example, if the Bytes object contains bytes representing the ASCII string "VMH", the output would be similar to this:
```
 c3 76 6d 68                                     # vmh:
 b6 03 56 4d 48                                  # VMH
 
```
    This is assumed to be used to print the contents on a best effort basis. If an Error occurs it will be returned in the String.
    Specified by:
    
    toHexString in interface Bytes<Void>
    
    Returns:
    
    A new hexadecimal String representing the content with comments describing the bytes.
  - 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 Object
  - retainedHexDumpDescription
```
public boolean retainedHexDumpDescription()
```
    Description copied from interface: HexDumpBytesDescription
    
    Do these Bytes support saving comments as descriptions for fields.
    
    Specified by:
    
    retainedHexDumpDescription in interface HexDumpBytesDescription<BytesOut<Void>>
    
    Returns:
    
    true if comments are for field descriptions
  - writeHexDumpDescription
```
public Bytes<Void> writeHexDumpDescription(@NotNull
                                           @NotNull CharSequence comment)
                                    throws IllegalStateException
```
    Description copied from interface: HexDumpBytesDescription
    
    Add comment as appropriate for the toHexString format
    
    Specified by:
    
    writeHexDumpDescription in interface HexDumpBytesDescription<BytesOut<Void>>
    
    Parameters:
    
    comment - to add (or ignore)
    
    Returns:
    
    this
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - adjustHexDumpIndentation
```
public BytesOut<Void> adjustHexDumpIndentation(int n)
                                        throws IllegalStateException
```
    Description copied from interface: HexDumpBytesDescription
    
    Adjust the indent for nested data
    
    Specified by:
    
    adjustHexDumpIndentation in interface HexDumpBytesDescription<BytesOut<Void>>
    
    Parameters:
    
    n - +1 indent in, -1 reduce indenting
    
    Returns:
    
    this.
    
    Throws:
    
    IllegalStateException
  - copy
```
public BytesStore copy()
```
    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<Void>
    
    Specified by:
    
    copy in interface BytesStore<Bytes<Void>,Void>
    
    Returns:
    
    A new Bytes object that is a copy of this object.
  - 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<Void>
    
    Returns:
    
    true if this Bytes object is elastic; false otherwise.
  - ensureCapacity
```
public void ensureCapacity(long desiredCapacity)
                    throws IllegalArgumentException,
                           IllegalStateException
```
    Description copied from interface: Bytes
    
    Ensures that this Bytes object has the capacity to accommodate the specified amount of data.
    If this Bytes object is elastic and doesn't have enough capacity, it will be resized. If it is not elastic and doesn't have enough capacity, a DecoratedBufferOverflowException will be thrown.
    
    Specified by:
    
    ensureCapacity in interface Bytes<Void>
    
    Specified by:
    
    ensureCapacity in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    desiredCapacity - The minimum capacity, in bytes, that is required.
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalArgumentException
    
    IllegalStateException
  - 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<Void>
    
    Specified by:
    
    bytesStore in interface BytesStore<Bytes<Void>,Void>
    
    Returns:
    
    The backing BytesStore, or null if there isn't one.
  - compact
```
@NotNull
public @NotNull Bytes<Void> compact()
```
    Description copied from interface: Bytes
    
    Compacts this Bytes object by moving the readPosition() to the start(), adjusting the readLimit()/writePosition() appropriately so that the readRemaining() is unchanged.
    This operation is useful to free up space for writing by discarding bytes that have already been read.
    NOTE: If the space freed in longs is less than 1/4 the readRemaining, this method does nothing to reduce movement overhead
    
    Specified by:
    
    compact in interface Bytes<Void>
    
    Returns:
    
    This Bytes object, for method chaining.
  - clear
```
@NotNull
public @NotNull Bytes<Void> 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<Void>
    
    Specified by:
    
    clear in interface StreamingCommon<Bytes<Void>>
    
    Returns:
    
    This Bytes object.
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - isDirectMemory
```
public boolean isDirectMemory()
```
    Description copied from interface: BytesStore
    
    Checks if this BytesStore uses direct memory.
    
    Specified by:
    
    isDirectMemory in interface BytesStore<Bytes<Void>,Void>
    
    Returns:
    
    true if it uses direct memory, 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<Void>,Void>
    
    Returns:
    
    the maximum capacity of the ByteStore
  - addressForRead
```
public long addressForRead(long offset)
                    throws UnsupportedOperationException,
                           IllegalStateException,
                           BufferUnderflowException
```
    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:
    
    UnsupportedOperationException - If the underlying buffer is on the heap
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If the offset is before the start() or the after the capacity()
    
    IllegalStateException
  - addressForWrite
```
public long addressForWrite(long offset)
                     throws UnsupportedOperationException
```
    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:
    
    UnsupportedOperationException - If the underlying buffer is on the heap
  - addressForWritePosition
```
public long addressForWritePosition()
                             throws UnsupportedOperationException,
                                    BufferOverflowException
```
    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:
    
    UnsupportedOperationException - If the underlying buffer is on the heap.
    
    BufferOverflowException - If the current write position is before the start or after the capacity.
  - compareAndSwapInt
```
public boolean compareAndSwapInt(long offset,
                                 int expected,
                                 int value)
                          throws BufferOverflowException,
                                 IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Performs a 32-bit compare-and-swap (CAS) operation at a given offset.
    
    Specified by:
    
    compareAndSwapInt in interface RandomDataOutput<Bytes<Void>>
    
    Parameters:
    
    offset - the offset at which to perform the CAS operation.
    
    expected - the expected current value.
    
    value - the new value to set if the current value matches the expected value.
    
    Returns:
    
    true if the CAS operation was successful, false otherwise.
    
    Throws:
    
    BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - testAndSetInt
```
public void testAndSetInt(long offset,
                          int expected,
                          int value)
                   throws IllegalStateException,
                          BufferOverflowException
```
    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 RandomDataOutput<Bytes<Void>>
    
    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:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.
    
    IllegalStateException
  - compareAndSwapLong
```
public boolean compareAndSwapLong(long offset,
                                  long expected,
                                  long value)
                           throws BufferOverflowException,
                                  IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Performs a 64-bit compare-and-swap (CAS) operation at a given offset.
    
    Specified by:
    
    compareAndSwapLong in interface RandomDataOutput<Bytes<Void>>
    
    Parameters:
    
    offset - the offset at which to perform the CAS operation.
    
    expected - the expected current value.
    
    value - the new value to set if the current value matches the expected value.
    
    Returns:
    
    true if the CAS operation was successful, false otherwise.
    
    Throws:
    
    BufferOverflowException - If the capacity of this RandomDataOutput was exceeded.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - underlyingObject
```
@Nullable
public @Nullable Void underlyingObject()
```
    Specified by:
    
    underlyingObject in interface BytesStore<Bytes<Void>,Void>
    
    Returns:
    
    the underlying object being wrapped, if there is one, or null if not.
  - move
```
public void move(long from,
                 long to,
                 long length)
```
    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<Void>,Void>
    
    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
  - reserve
```
public void reserve(net.openhft.chronicle.core.io.ReferenceOwner owner)
             throws IllegalStateException
```
    Specified by:
    
    reserve in interface net.openhft.chronicle.core.io.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - release
```
public void release(net.openhft.chronicle.core.io.ReferenceOwner owner)
             throws IllegalStateException
```
    Specified by:
    
    release in interface net.openhft.chronicle.core.io.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - releaseLast
```
public void releaseLast(net.openhft.chronicle.core.io.ReferenceOwner owner)
                 throws IllegalStateException
```
    Specified by:
    
    releaseLast in interface net.openhft.chronicle.core.io.ReferenceCounted
    
    Throws:
    
    IllegalStateException
  - refCount
```
public int refCount()
```
    Specified by:
    
    refCount in interface net.openhft.chronicle.core.io.ReferenceCounted
  - addReferenceChangeListener
```
public void addReferenceChangeListener(net.openhft.chronicle.core.io.ReferenceChangeListener referenceChangeListener)
```
    Specified by:
    
    addReferenceChangeListener in interface net.openhft.chronicle.core.io.ReferenceCounted
  - removeReferenceChangeListener
```
public void removeReferenceChangeListener(net.openhft.chronicle.core.io.ReferenceChangeListener referenceChangeListener)
```
    Specified by:
    
    removeReferenceChangeListener in interface net.openhft.chronicle.core.io.ReferenceCounted
  - tryReserve
```
public boolean tryReserve(net.openhft.chronicle.core.io.ReferenceOwner owner)
                   throws IllegalStateException,
                          IllegalArgumentException
```
    Specified by:
    
    tryReserve in interface net.openhft.chronicle.core.io.ReferenceCounted
    
    Throws:
    
    IllegalStateException
    
    IllegalArgumentException
  - writeByte
```
@NotNull
public @NotNull Bytes<Void> writeByte(long offset,
                                               byte i8)
                                        throws BufferOverflowException,
                                               IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a byte at the specified non-negative offset.
    
    Specified by:
    
    writeByte in interface RandomDataOutput<Bytes<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the byte to.
    
    i8 - The byte value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeShort
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the short integer to.
    
    i - The short integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeInt24
```
@NotNull
public @NotNull Bytes<Void> writeInt24(long offset,
                                                int i)
                                         throws BufferOverflowException,
                                                IllegalStateException
```
    Description copied from interface: RandomDataOutput
    
    Writes a 24-bit integer at the specified non-negative offset. This method writes the lower 16 bits and then the upper 8 bits of the integer in two steps.
    
    Specified by:
    
    writeInt24 in interface RandomDataOutput<Bytes<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the 24-bit integer to.
    
    i - The integer value to write. Only the lowest 24 bits are used.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset plus two exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeInt
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the integer to.
    
    i - The integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeOrderedInt
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the integer to.
    
    i - The integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeLong
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the long integer to.
    
    i - The long integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeOrderedLong
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the long integer to.
    
    i - The long integer value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeFloat
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the float to.
    
    d - The float value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeDouble
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    offset - The non-negative position within the data stream to write the double to.
    
    d - The double value to write.
    
    Returns:
    
    Reference to the current instance, allowing for method chaining.
    
    Throws:
    
    BufferOverflowException - If the specified offset exceeds the available capacity.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeVolatileByte
```
@NotNull
public @NotNull Bytes<Void> writeVolatileByte(long offset,
                                                       byte i8)
                                                throws BufferOverflowException
```
    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<Void>>
    
    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.
  - writeVolatileShort
```
@NotNull
public @NotNull Bytes<Void> writeVolatileShort(long offset,
                                                        short i16)
                                                 throws BufferOverflowException
```
    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<Void>>
    
    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.
  - writeVolatileInt
```
@NotNull
public @NotNull Bytes<Void> writeVolatileInt(long offset,
                                                      int i32)
                                               throws BufferOverflowException
```
    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<Void>>
    
    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.
  - writeVolatileLong
```
@NotNull
public @NotNull Bytes<Void> writeVolatileLong(long offset,
                                                       long i64)
                                                throws BufferOverflowException
```
    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<Void>>
    
    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.
  - write
```
@NotNull
public @NotNull Bytes<Void> write(long offsetInRDO,
                                           byte[] byteArray,
                                           int offset,
                                           int length)
```
    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<Void>>
    
    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.
  - write
```
public void write(long offsetInRDO,
                  @NotNull
                  @NotNull ByteBuffer bytes,
                  int offset,
                  int length)
```
    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<Void>>
    
    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.
  - write
```
@NotNull
public @NotNull Bytes<Void> write(long writeOffset,
                                           @NotNull
                                           @NotNull RandomDataInput bytes,
                                           long readOffset,
                                           long length)
```
    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<Void>>
    
    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.
  - 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<Void>>
    
    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<Void>>
    
    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.
  - nativeWrite
```
public void nativeWrite(long address,
                        long position,
                        long size)
```
    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<Void>>
    
    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.
  - zeroOut
```
@NotNull
public @NotNull Bytes<Void> zeroOut(long start,
                                             long end)
                                      throws IllegalStateException
```
    Description copied from interface: BytesStore
    
    Fills the BytesStore with zeros.
    
    Specified by:
    
    zeroOut in interface BytesStore<Bytes<Void>,Void>
    
    Specified by:
    
    zeroOut in interface RandomDataOutput<Bytes<Void>>
    
    Parameters:
    
    start - first byte inclusive
    
    end - last byte exclusive
    
    Returns:
    
    this
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readPosition
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readLimit
```
@NotNull
public @NotNull Bytes<Void> readLimit(long limit)
                                        throws BufferUnderflowException
```
    Description copied from interface: StreamingDataInput
    
    Sets the read limit of this StreamingDataInput.
    
    Specified by:
    
    readLimit in interface StreamingDataInput<Bytes<Void>>
    
    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
  - readSkip
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
  - 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<Void>>
  - readStopBit
```
public long readStopBit()
                 throws net.openhft.chronicle.core.io.IORuntimeException,
                        IllegalStateException,
                        BufferUnderflowException
```
    Description copied from interface: StreamingDataInput
    
    Reads a variable-length integer encoded using the stop bit encoding. This method is equivalent to calling BytesInternal.readStopBit(this).
    
    Specified by:
    
    readStopBit in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the decoded integer
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If an I/O error occurs
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If there's not enough data to read
    
    IllegalStateException
  - readStopBitChar
```
public char readStopBitChar()
                     throws net.openhft.chronicle.core.io.IORuntimeException,
                            IllegalStateException,
                            BufferUnderflowException
```
    Description copied from interface: StreamingDataInput
    
    Reads a variable-length character encoded using the stop bit encoding. This method is equivalent to calling BytesInternal.readStopBitChar(this).
    
    Specified by:
    
    readStopBitChar in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the decoded character
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If an I/O error occurs
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If there's not enough data to read
    
    IllegalStateException
  - readStopBitDouble
```
public double readStopBitDouble()
                         throws IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads a variable-length double encoded using the stop bit encoding. This method is equivalent to calling BytesInternal.readStopBitDouble(this).
    
    Specified by:
    
    readStopBitDouble in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the decoded double
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readStopBitDecimal
```
public double readStopBitDecimal()
                          throws IllegalStateException,
                                 BufferUnderflowException
```
    Description copied from interface: StreamingDataInput
    
    Reads a decimal number represented as a variable-length double and scale encoded using the stop bit encoding. The absolute value of the returned double represents the value of the decimal, and the sign represents the sign of the decimal.
    
    Specified by:
    
    readStopBitDecimal in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the decoded decimal number
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If there's not enough data to read
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the byte value
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the next unsigned 8-bit value or -1
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the next unsigned 8-bit value or -1
  - 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<Void>>
    
    Returns:
    
    the 16-bit short value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the 32-bit integer value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the 64-bit long value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the float value read from the stream
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the double value read from the stream
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the read integer value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the read long value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    Returns:
    
    the peeked byte value
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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<Void>>
    
    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<Void>>
    
    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<Void>>
    
    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<Void>>
    
    Parameters:
    
    lastNumberHadDigits - the new value to set, true if the last parsed number had digits, false otherwise.
  - readBigDecimal
```
@NotNull
public @NotNull BigDecimal readBigDecimal()
                                            throws BufferUnderflowException,
                                                   ArithmeticException,
                                                   IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Creates and returns a new BigDecimal representing the contents of this Bytes object.
    If this Byte object is empty, an object equal to BigDecimal.ZERO is returned.
    
    Specified by:
    
    readBigDecimal in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    a new BigDecimal
    
    Throws:
    
    BufferUnderflowException - If the content of this Bytes object is insufficient to be successfully converted
    
    ArithmeticException - If the content of this Bytes object could not be successfully converted
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readBigInteger
```
@NotNull
public @NotNull BigInteger readBigInteger()
                                            throws BufferUnderflowException,
                                                   ArithmeticException,
                                                   IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Creates and returns a new BigInteger representing the contents of this Bytes object or BigInteger.ZERO if this Bytes object is empty.
    
    Specified by:
    
    readBigInteger in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    a new BigInteger
    
    Throws:
    
    BufferUnderflowException - If the content of this Bytes object is insufficient to be successfully converted
    
    ArithmeticException - If the content of this Bytes object could not be successfully converted
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readWithLength
```
public void readWithLength(long length,
                           @NotNull
                           @NotNull BytesOut<Void> bytesOut)
                    throws BufferUnderflowException,
                           net.openhft.chronicle.core.io.IORuntimeException,
                           IllegalStateException,
                           BufferOverflowException
```
    Description copied from interface: Bytes
    
    Writes the specified number of bytes from this Bytes object into the provided bytesOut.
    This operation does not affect the readLimit or readPosition of this Bytes object.
    
    Specified by:
    
    readWithLength in interface Bytes<Void>
    
    Parameters:
    
    length - The number of bytes to write. Must be non-negative.
    
    bytesOut - The target BytesOut object to write to. Must not be null.
    
    Throws:
    
    BufferUnderflowException - If the specified length is greater than the number of bytes available for reading from this Bytes object.
    
    net.openhft.chronicle.core.io.IORuntimeException - If an error occurs while reading from this Bytes object or writing to bytesOut.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If bytesOut does not have enough capacity to hold the bytes being written.
    
    IllegalStateException
  - readMarshallableLength16
```
public <T extends ReadBytesMarshallable> T readMarshallableLength16(@NotNull
                                                                    @NotNull Class<T> clazz,
                                                                    @Nullable
                                                                    T using)
                                                             throws BufferUnderflowException,
                                                                    IllegalStateException,
                                                                    net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Description copied from interface: Bytes
    
    Reads the content of this Bytes object and converts it into an instance of the specified class. Optionally updates the provided instance if not null. The content is assumed to have a 16-bit length indicator preceding the actual object data.
    If the using parameter is not null, this method will update its state with the read content. Otherwise, it will create a new instance of the specified class.
    
    Specified by:
    
    readMarshallableLength16 in interface Bytes<Void>
    
    Specified by:
    
    readMarshallableLength16 in interface BytesIn<Void>
    
    Type Parameters:
    
    T - The type of the object being read.
    
    Parameters:
    
    clazz - The class of the object to be read. Must not be null.
    
    using - An optional instance to update with the read content. Can be null.
    
    Returns:
    
    The object that was read from this Bytes object, or the updated instance if using was provided.
    
    Throws:
    
    BufferUnderflowException - If there are not enough bytes in this Bytes object to read the content.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the data in this Bytes object cannot be converted into an instance of the specified class.
    
    IllegalStateException
    
    See Also:
    
    Bytes.writeMarshallableLength16(WriteBytesMarshallable)
  - readPositionUnlimited
```
@NotNull
public @NotNull Bytes<Void> readPositionUnlimited(long position)
                                                    throws BufferUnderflowException,
                                                           IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Sets the read position of this StreamingDataInput without limiting it to the current read limit.
    
    Specified by:
    
    readPositionUnlimited in interface StreamingDataInput<Bytes<Void>>
    
    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 capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readPositionRemaining
```
@NotNull
public @NotNull Bytes<Void> readPositionRemaining(long position,
                                                           long remaining)
                                                    throws BufferUnderflowException,
                                                           IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Sets the read position and limit of this StreamingDataInput based on the specified position and remaining values.
    
    Specified by:
    
    readPositionRemaining in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    position - the new read position, must be non-negative
    
    remaining - the remaining size, which is used to set the read limit
    
    Returns:
    
    this StreamingDataInput instance, for chaining
    
    Throws:
    
    BufferUnderflowException - If the new position is greater than the read limit
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readWithLength0
```
public void readWithLength0(long length,
                            @NotNull
                            @NotNull net.openhft.chronicle.core.util.ThrowingConsumerNonCapturing<Bytes<Void>,net.openhft.chronicle.core.io.IORuntimeException,BytesOut> bytesConsumer,
                            StringBuilder sb,
                            BytesOut<?> toBytes)
                     throws BufferUnderflowException,
                            net.openhft.chronicle.core.io.IORuntimeException,
                            IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Perform a set of actions within a temporary bounds mode. The bounds are defined by the specified length. After the consumer has been executed, the original read limit is restored and the read position is moved forward by the specified length.
    
    Specified by:
    
    readWithLength0 in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    length - the length to set the temporary bounds to
    
    bytesConsumer - the consumer to execute within the temporary bounds
    
    sb - the StringBuilder to use
    
    toBytes - the BytesOut to use
    
    Throws:
    
    BufferUnderflowException - If the specified length is greater than the number of bytes remaining to read
    
    net.openhft.chronicle.core.io.IORuntimeException - If the bytesConsumer encounters an IO error
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readWithLength
```
public void readWithLength(long length,
                           @NotNull
                           @NotNull net.openhft.chronicle.core.util.ThrowingConsumer<Bytes<Void>,net.openhft.chronicle.core.io.IORuntimeException> bytesConsumer)
                    throws BufferUnderflowException,
                           net.openhft.chronicle.core.io.IORuntimeException,
                           IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Perform a set of actions within a temporary bounds mode. The bounds are defined by the specified length. After the consumer has been executed, the original read limit is restored and the read position is moved forward by the specified length.
    
    Specified by:
    
    readWithLength in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    length - the length to set the temporary bounds to
    
    bytesConsumer - the consumer to execute within the temporary bounds
    
    Throws:
    
    BufferUnderflowException - If the specified length is greater than the number of bytes remaining to read
    
    net.openhft.chronicle.core.io.IORuntimeException - If the bytesConsumer encounters an IO error
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readBoolean
```
public boolean readBoolean()
                    throws IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads a boolean value from the input stream. It reads a byte and converts it into a boolean using BytesUtil.byteToBoolean(b).
    
    Specified by:
    
    readBoolean in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the boolean value
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readUnsignedShort
```
public int readUnsignedShort()
                      throws BufferUnderflowException,
                             IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads a 16-bit value from the input stream and converts it to an unsigned short by masking the sign bit.
    
    Specified by:
    
    readUnsignedShort in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the unsigned 16-bit value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readInt24
```
public int readInt24()
              throws BufferUnderflowException,
                     IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads a 24-bit signed integer value from the input stream. This is achieved by reading an unsigned short and an unsigned byte, and then bit-shifting and combining them to form a 24-bit integer.
    
    Specified by:
    
    readInt24 in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the 24-bit integer value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readUnsignedInt24
```
public int readUnsignedInt24()
                      throws BufferUnderflowException,
                             IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads a 24-bit unsigned integer value from the input stream. This is achieved by reading an unsigned short and an unsigned byte, and then bit-shifting and combining them to form a 24-bit unsigned integer.
    
    Specified by:
    
    readUnsignedInt24 in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the 24-bit unsigned integer value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readUnsignedInt
```
public long readUnsignedInt()
                     throws BufferUnderflowException,
                            IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads a 32-bit value from the input stream and converts it to an unsigned integer by masking the sign bit.
    
    Specified by:
    
    readUnsignedInt in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    the unsigned 32-bit integer value
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - readUtf8
```
@Nullable
public @Nullable String readUtf8()
                                    throws BufferUnderflowException,
                                           net.openhft.chronicle.core.io.IORuntimeException,
                                           IllegalStateException,
                                           ArithmeticException
```
    Description copied from interface: StreamingDataInput
    
    Reads a UTF-8 encoded string from the input stream. This method supports null values and utilizes stop bit encoding for length, saving one byte for strings shorter than 128 characters.
    
    Specified by:
    
    readUtf8 in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    a Unicode string or null if writeUtf8(null) was called
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.IORuntimeException - If an IO error occurs
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    ArithmeticException - If numeric overflow or underflow occurs
    
    IllegalStateException
  - read8bit
```
@Nullable
public @Nullable String read8bit()
                                    throws net.openhft.chronicle.core.io.IORuntimeException,
                                           BufferUnderflowException,
                                           IllegalStateException,
                                           ArithmeticException
```
    Description copied from interface: StreamingDataInput
    
    Reads an 8-bit encoded string from the input stream.
    
    Specified by:
    
    read8bit in interface StreamingDataInput<Bytes<Void>>
    
    Returns:
    
    an 8-bit string or null if write8bit(null) was called
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If an IO error occurs
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    ArithmeticException - If numeric overflow or underflow occurs
    
    IllegalStateException
  - readUtf8
```
public <C extends Appendable & CharSequence> boolean readUtf8(@NotNull
                                                              C sb)
                                                       throws net.openhft.chronicle.core.io.IORuntimeException,
                                                              IllegalArgumentException,
                                                              BufferUnderflowException,
                                                              IllegalStateException,
                                                              ArithmeticException
```
    Description copied from interface: StreamingDataInput
    
    Reads a UTF-8 encoded string from the input stream and appends it to the provided appendable. This method is similar to readUtf8(), except it populates a provided appendable instead of creating a new string.
    
    Specified by:
    
    readUtf8 in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    sb - the appendable to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If an IO error occurs
    
    IllegalArgumentException - If the appendable does not allow setting length
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    ArithmeticException - If numeric overflow or underflow occurs
    
    IllegalStateException
  - readUtf8
```
public <C extends Appendable & CharSequence> long readUtf8(long offset,
                                                           @NotNull
                                                           C sb)
                                                    throws net.openhft.chronicle.core.io.IORuntimeException,
                                                           IllegalArgumentException,
                                                           BufferUnderflowException,
                                                           ArithmeticException,
                                                           IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it. Returns offset after the read Utf8, if a normal char sequence was read, or -1 - offset, if null was observed (in this case, sb is truncated too, but not updated then, by querying sb only this case is indistinguishable from reading an empty char sequence).
    
    Specified by:
    
    readUtf8 in interface RandomDataInput
    
    Type Parameters:
    
    C - buffer type, must be StringBuilder or Bytes
    
    Parameters:
    
    offset - the offset in this RandomDataInput to read char sequence from
    
    sb - the buffer to read char sequence into (truncated first)
    
    Returns:
    
    offset after the normal read char sequence, or -1 - offset, if char sequence is null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If the reading operation encounters an unexpected error.
    
    IllegalArgumentException - If the buffer is not a StringBuilder or Bytes.
    
    BufferUnderflowException - If the reading operation encounters the end of the byte source.
    
    ArithmeticException - If the calculated length of the UTF-8 encoded string is invalid.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    See Also:
    
    RandomDataOutput.writeUtf8(long, CharSequence)
  - readUtf8Limited
```
public <C extends Appendable & CharSequence> long readUtf8Limited(long offset,
                                                                  @NotNull
                                                                  C sb,
                                                                  int maxUtf8Len)
                                                           throws net.openhft.chronicle.core.io.IORuntimeException,
                                                                  IllegalArgumentException,
                                                                  BufferUnderflowException,
                                                                  IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    Truncates sb (it must be a StringBuilder or Bytes) and reads a char sequence from the given offset, encoded as Utf8, into it. Returns offset after the read Utf8, if a normal char sequence was read, or -1 - offset, if null was observed (in this case, sb is truncated too, but not updated then, by querying sb only this case is indistinguishable from reading an empty char sequence). If length of Utf8 encoding of the char sequence exceeds maxUtf8Len, ClosedIllegalStateException is thrown.
    
    Specified by:
    
    readUtf8Limited in interface RandomDataInput
    
    Type Parameters:
    
    C - buffer type, must be StringBuilder or Bytes
    
    Parameters:
    
    offset - the offset in this RandomDataInput to read char sequence from
    
    sb - the buffer to read char sequence into (truncated first)
    
    maxUtf8Len - the maximum allowed length of the char sequence in Utf8 encoding
    
    Returns:
    
    offset after the normal read char sequence, or -1 - offset, if char sequence is null
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    BufferUnderflowException
    
    IllegalStateException
    
    See Also:
    
    RandomDataOutput.writeUtf8Limited(long, CharSequence, int)
  - readUtf8Limited
```
@Nullable
public @Nullable String readUtf8Limited(long offset,
                                                  int maxUtf8Len)
                                           throws BufferUnderflowException,
                                                  net.openhft.chronicle.core.io.IORuntimeException,
                                                  IllegalArgumentException,
                                                  IllegalStateException
```
    Description copied from interface: RandomDataInput
    
    Reads a char sequence from the given offset, encoded as Utf8. If length of Utf8 encoding of the char sequence exceeds maxUtf8Len, ClosedIllegalStateException is thrown.
    
    Specified by:
    
    readUtf8Limited in interface RandomDataInput
    
    Parameters:
    
    offset - the offset in this RandomDataInput to read char sequence from
    
    maxUtf8Len - the maximum allowed length of the char sequence in Utf8 encoding
    
    Returns:
    
    the char sequence was read
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException
    
    net.openhft.chronicle.core.io.IORuntimeException
    
    IllegalArgumentException
    
    IllegalStateException
    
    See Also:
    
    RandomDataOutput.writeUtf8Limited(long, CharSequence, int)
  - read8bit
```
public boolean read8bit(@NotNull
                        @NotNull Bytes<?> b)
                 throws BufferUnderflowException,
                        IllegalStateException,
                        BufferOverflowException,
                        ArithmeticException
```
    Description copied from interface: StreamingDataInput
    
    Reads an 8-bit encoded string from the input stream and appends it to the provided Bytes.
    
    Specified by:
    
    read8bit in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    b - the Bytes instance to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If the buffer is full
    
    ArithmeticException - If numeric overflow or underflow occurs
    
    IllegalStateException
  - read8bit
```
public boolean read8bit(@NotNull
                        @NotNull StringBuilder sb)
                 throws net.openhft.chronicle.core.io.IORuntimeException,
                        BufferUnderflowException,
                        ArithmeticException,
                        IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads an 8-bit encoded string from the input stream and appends it to the provided StringBuilder.
    
    Specified by:
    
    read8bit in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    sb - the StringBuilder to which the read string will be appended
    
    Returns:
    
    true if there was a String, or false if it was null
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If an IO error occurs
    
    BufferUnderflowException - If there's not enough data to read
    
    ArithmeticException - If numeric overflow or underflow occurs
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - read
```
public int read(byte[] bytes)
         throws IllegalStateException,
                BufferUnderflowException
```
    Description copied from interface: StreamingDataInput
    
    Reads the input stream into the provided byte array.
    
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    bytes - the byte array to fill with the read data
    
    Returns:
    
    the number of bytes read, or -1 if the end of the stream is reached
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If there's not enough data to read
    
    IllegalStateException
  - read
```
public int read(byte[] bytes,
                int off,
                int len)
         throws IllegalStateException,
                BufferUnderflowException
```
    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<Void>>
    
    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:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If there's not enough data to read
    
    IllegalStateException
  - read
```
public int read(char[] bytes,
                int off,
                int len)
         throws IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads the input stream into the provided char array, starting from the given offset and reading up to the specified length.
    
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    bytes - the char array to fill with the read data
    
    off - the start offset in the char array
    
    len - the maximum number of chars to read
    
    Returns:
    
    the number of chars read, or -1 if the end of the stream is reached
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - read
```
public void read(@NotNull
                 @NotNull ByteBuffer buffer)
          throws IllegalStateException
```
    Description copied from interface: StreamingDataInput
    
    Reads the input stream into the provided ByteBuffer.
    
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    buffer - the ByteBuffer to fill with the read data
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - read
```
public void read(@NotNull
                 @NotNull Bytes<?> bytes,
                 int length)
          throws BufferUnderflowException,
                 IllegalStateException,
                 BufferOverflowException
```
    Description copied from interface: StreamingDataInput
    
    Transfers the specified number of bytes from the input stream into the provided Bytes object.
    
    Specified by:
    
    read in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    bytes - the Bytes object to fill with the read data
    
    length - the number of bytes to read
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there's not enough space in the provided Bytes object
    
    IllegalStateException
  - readEnum
```
@NotNull
public <E extends Enum<E>> E readEnum(@NotNull
                                               @NotNull Class<E> eClass)
                                        throws net.openhft.chronicle.core.io.IORuntimeException,
                                               BufferUnderflowException,
                                               IllegalStateException,
                                               ArithmeticException,
                                               BufferOverflowException
```
    Description copied from interface: StreamingDataInput
    
    Reads an Enum value from the input stream.
    
    Specified by:
    
    readEnum in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    eClass - the class of the Enum
    
    Returns:
    
    the read Enum value
    
    Throws:
    
    net.openhft.chronicle.core.io.IORuntimeException - If an I/O error occurs
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    ArithmeticException - If the number format is invalid
    
    BufferOverflowException - If there's not enough space in the buffer
    
    IllegalStateException
  - readHistogram
```
public void readHistogram(@NotNull
                          @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                   throws BufferUnderflowException,
                          IllegalStateException,
                          ArithmeticException
```
    Description copied from interface: StreamingDataInput
    
    Reads data from the input stream into the provided Histogram.
    
    Specified by:
    
    readHistogram in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    histogram - the Histogram to fill with data
    
    Throws:
    
    BufferUnderflowException - If there's not enough data to read
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    ArithmeticException - If the number format is invalid
    
    IllegalStateException
  - readWithLength
```
public void readWithLength(@NotNull
                           @NotNull Bytes<?> bytes)
                    throws ArithmeticException,
                           BufferOverflowException,
                           IllegalStateException,
                           BufferUnderflowException
```
    Description copied from interface: StreamingDataInput
    
    Reads data from the input stream with specified length into the provided Bytes.
    
    Specified by:
    
    readWithLength in interface StreamingDataInput<Bytes<Void>>
    
    Parameters:
    
    bytes - the Bytes to fill with data
    
    Throws:
    
    ArithmeticException - If the number format is invalid
    
    BufferOverflowException - If there's not enough space in the buffer
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If there's not enough data to read
    
    IllegalStateException
  - writePosition
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
  - writeLimit
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
  - writeSkip
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeByte
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    i8 - The byte to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writePosition
```
public long writePosition()
```
    For HexDumpBytes it needs to remember the writePosition for the underlying bytes as well as the text hex dump, so it encodes both in one number so you can call writePosition later.
    
    Returns:
    
    the base and text writePositions.
  - lengthWritten
```
public long lengthWritten(long startPosition)
```
    Calculates the length of data written from the given start position.
    Typically this calculates the difference however for HexDumpBytes it's not as simple.
    If the resource is closed, the returned value is unspecified.
    
    Parameters:
    
    startPosition - The position to calculate the length from.
    
    Returns:
    
    The length of data written from the given start position.
  - writeShort
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    i16 - The short integer to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeInt
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    i - The integer to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeIntAdv
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeLong
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    i64 - The long integer to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeLongAdv
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeFloat
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    f - The floating-point number to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeDouble
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeDoubleAndInt
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - write
```
@NotNull
public @NotNull Bytes<Void> write(byte[] byteArray,
                                           int offset,
                                           int length)
                                    throws BufferOverflowException,
                                           IllegalArgumentException,
                                           IllegalStateException
```
    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<Void>>
    
    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.
    
    IllegalArgumentException - If the provided offset or length is negative
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeSome
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferUnderflowException - If there is not enough data available in the input ByteBuffer.
    
    IllegalStateException
  - writeOrderedInt
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeOrderedLong
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - clearAndPad
```
@NotNull
public @NotNull Bytes<Void> clearAndPad(long length)
                                          throws BufferOverflowException,
                                                 IllegalStateException
```
    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<Void>>
    
    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()
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - prewrite
```
@NotNull
public @NotNull Bytes<Void> prewrite(byte[] bytes)
```
    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<Void>>
    
    Parameters:
    
    bytes - the byte array to prepend
    
    Returns:
    
    this instance, after the operation
  - prewrite
```
@NotNull
public @NotNull Bytes<Void> prewrite(BytesStore bytes)
```
    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<Void>>
    
    Parameters:
    
    bytes - the BytesStore to prepend
    
    Returns:
    
    this instance, after the operation
  - prewriteByte
```
@NotNull
public @NotNull Bytes<Void> prewriteByte(byte b)
```
    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<Void>>
    
    Parameters:
    
    b - the byte to prepend
    
    Returns:
    
    this instance, after the operation
  - prewriteShort
```
@NotNull
public @NotNull Bytes<Void> prewriteShort(short i)
```
    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<Void>>
    
    Parameters:
    
    i - the short to prepend
    
    Returns:
    
    this instance, after the operation
  - prewriteInt
```
@NotNull
public @NotNull Bytes<Void> prewriteInt(int i)
```
    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<Void>>
    
    Parameters:
    
    i - the int to prepend
    
    Returns:
    
    this instance, after the operation
  - prewriteLong
```
@NotNull
public @NotNull Bytes<Void> prewriteLong(long l)
```
    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<Void>>
    
    Parameters:
    
    l - the long to prepend
    
    Returns:
    
    this instance, after the operation
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - peekUnsignedByte
```
public int peekUnsignedByte(long offset)
                     throws IllegalStateException,
                            BufferUnderflowException
```
    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:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    BufferUnderflowException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - 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.
  - 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<Void>>
    
    Parameters:
    
    lenient - if true, return nothing rather than error.
  - lenient
```
public boolean lenient()
```
    Specified by:
    
    lenient in interface StreamingDataInput<Bytes<Void>>
  - append
```
@NotNull
public @NotNull Bytes<Void> append(char ch)
                                     throws IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a UTF-8 encoded character to the buffer.
    
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    ch - the character to append
    
    Returns:
    
    the ByteStringAppender instance with the appended character
    
    Throws:
    
    IllegalStateException
  - append
```
@NotNull
public @NotNull Bytes<Void> append(@NotNull
                                            @NotNull CharSequence cs)
```
    Description copied from interface: ByteStringAppender
    
    Append a characters in UTF-8
    
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    cs - the CharSequence to append
    
    Returns:
    
    this
  - append
```
@NotNull
public @NotNull Bytes<Void> append(boolean flag)
                                     throws BufferOverflowException,
                                            IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a boolean as 'T' or 'F' character.
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    flag - to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - append
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    value - the integer value to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalArgumentException
    
    IllegalStateException
  - append
```
@NotNull
public @NotNull Bytes<Void> append(long value)
                                     throws BufferOverflowException,
                                            IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a long value in decimal.
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    value - the long number to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - appendBase
```
@NotNull
public @NotNull Bytes<Void> appendBase(long value,
                                                int base)
                                         throws BufferOverflowException,
                                                IllegalArgumentException,
                                                IllegalStateException,
                                                IndexOutOfBoundsException
```
    Description copied from interface: ByteStringAppender
    
    Appends a string representation of the first argument in the radix specified by the second argument.
    
    Specified by:
    
    appendBase in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    value - the number to append
    
    base - the radix that the specified value should be converted to before append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    IllegalArgumentException - If the specified arguments are illegal
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
    
    IndexOutOfBoundsException
  - appendBase16
```
@NotNull
public @NotNull Bytes<Void> appendBase16(long value)
                                           throws BufferOverflowException,
                                                  IllegalArgumentException,
                                                  IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends the base 16 (hexadecimal) representation of the specified long value.
    
    Specified by:
    
    appendBase16 in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    value - the long value to be converted to base 16 and appended
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    IllegalArgumentException - If the specified argument is illegal
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - appendBase16
```
@NotNull
public @NotNull Bytes<Void> appendBase16(long value,
                                                  int minDigits)
                                           throws BufferOverflowException,
                                                  IllegalArgumentException,
                                                  IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends the base 16 (hexadecimal) representation of the specified long value, padding with leading zeroes if the number of digits is less than minDigits.
    
    Specified by:
    
    appendBase16 in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    value - the long value to be converted to base 16 and appended
    
    minDigits - the minimum number of digits to be appended
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    IllegalArgumentException - If the specified argument is illegal
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - appendDecimal
```
@NotNull
public @NotNull Bytes<Void> appendDecimal(long value,
                                                   int decimalPlaces)
                                            throws BufferOverflowException,
                                                   IllegalStateException,
                                                   ArithmeticException,
                                                   IllegalArgumentException
```
    Description copied from interface: ByteStringAppender
    
    Appends a long in decimal with a given number of decimal places. Prints value * 10^-decimalPlaces
    
    Specified by:
    
    appendDecimal in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    value - to append
    
    decimalPlaces - to shift the decimal place
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalArgumentException - If the decimalPlaces is negative or too large
    
    IllegalStateException
    
    ArithmeticException
  - append
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
    
    ArithmeticException
  - decimaliser
```
public Decimaliser decimaliser()
```
    Description copied from interface: ByteStringAppender
    
    Gets the Decimaliser currently associated with this ByteStringAppender.
    
    Specified by:
    
    decimaliser in interface ByteStringAppender<Bytes<Void>>
    
    Returns:
    
    The Decimaliser currently associated with this ByteStringAppender.
  - decimaliser
```
public Bytes<Void> 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<Void>>
    
    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<Void>>
    
    Returns:
    
    whether floating point add .0 to indicate it is a floating point even if redundant.
  - fpAppend0
```
public Bytes<Void> fpAppend0(boolean append0)
```
    Specified by:
    
    fpAppend0 in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    append0 - Does floating point add .0 to indicate it is a floating point even if redundant.
    
    Returns:
    
    this
  - append
```
public void append(boolean isNegative,
                   long mantissa,
                   int exponent)
```
    Description copied from interface: DecimalAppender
    
    Appends a decimal number, represented by its sign, mantissa, and exponent, to a target. The target can be any object that consumes these components, such as a StringBuilder or a file stream.
    
    Specified by:
    
    append in interface DecimalAppender
    
    Parameters:
    
    isNegative - Whether the number is negative. true indicates a negative number, false indicates a positive number.
    
    mantissa - The significant digits of the decimal number, represented as a long integer.
    
    exponent - The power of 10 by which the mantissa is scaled to obtain the actual decimal number.
  - appendAndReturnLength
```
public long appendAndReturnLength(long writePosition,
                                  boolean negative,
                                  long mantissa,
                                  int exponent,
                                  boolean append0)
```
    Specified by:
    
    appendAndReturnLength in interface RandomDataOutput<Bytes<Void>>
  - append
```
@NotNull
public @NotNull Bytes<Void> append(@NotNull
                                            @NotNull CharSequence cs,
                                            int start,
                                            int end)
                                     throws IndexOutOfBoundsException
```
    Description copied from interface: ByteStringAppender
    
    Appends a portion of a string to the Bytes in UTF-8.
    
    Specified by:
    
    append in interface Appendable
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    cs - the CharacterSequence to append
    
    start - index of the first char inclusive
    
    end - index of the last char exclusive
    
    Returns:
    
    this
    
    Throws:
    
    IndexOutOfBoundsException - If the specified indexes are out of range
  - append8bit
```
@NotNull
public @NotNull Bytes<Void> append8bit(@NotNull
                                                @NotNull CharSequence cs)
                                         throws BufferOverflowException,
                                                BufferUnderflowException,
                                                IndexOutOfBoundsException,
                                                IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a String to the Bytes in ISO-8859-1.
    
    Specified by:
    
    append8bit in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    cs - the CharSequence to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the string is too large to write in the capacity available
    
    BufferUnderflowException - If the capacity of the underlying buffer was exceeded
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IndexOutOfBoundsException
    
    IllegalStateException
  - append8bit
```
public Bytes<Void> append8bit(@NotNull
                              @NotNull BytesStore bs)
                       throws BufferOverflowException,
                              BufferUnderflowException,
                              IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends the ISO-8859-1 representation of the specified BytesStore.
    
    Specified by:
    
    append8bit in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    bs - the BytesStore to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the BytesStore is too large to write in the capacity available
    
    BufferUnderflowException - If the capacity of the underlying buffer was exceeded
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - append8bit
```
public Bytes<Void> append8bit(@NotNull
                              @NotNull String cs)
                       throws BufferOverflowException,
                              IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends the ISO-8859-1 representation of the specified String.
    
    Specified by:
    
    append8bit in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    cs - the String to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the string is too large to write in the capacity available
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - append8bit
```
public Bytes<Void> append8bit(@NotNull
                              @NotNull CharSequence cs,
                              int start,
                              int end)
                       throws IllegalArgumentException,
                              BufferOverflowException,
                              BufferUnderflowException,
                              IndexOutOfBoundsException,
                              IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a portion of a string to this Bytes in ISO-8859-1.
    
    Specified by:
    
    append8bit in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    cs - the CharSequence to append
    
    start - index of the first char of cs (inclusive) to append
    
    end - index of the last char of cs (exclusive) to append
    
    Returns:
    
    this
    
    Throws:
    
    IllegalArgumentException - If the start or end is negative or too large
    
    BufferOverflowException - If the string is too large to write in the capacity available
    
    BufferUnderflowException - If the capacity of the underlying buffer was exceeded
    
    IndexOutOfBoundsException - If the start or the end are not valid for the CharSequence
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - append8bit
```
public Bytes<Void> append8bit(@NotNull
                              @NotNull BytesStore bs,
                              long start,
                              long end)
                       throws IllegalArgumentException,
                              BufferOverflowException,
                              BufferUnderflowException,
                              IndexOutOfBoundsException,
                              IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a portion of a BytesStore to this in ISO-8859-1 format.
    
    Specified by:
    
    append8bit in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    bs - the specified BytesStore that a portion of it will be appended to this
    
    start - the index of first byte (inclusive) of bs to append
    
    end - the number of bytes of bs to append
    
    Returns:
    
    this
    
    Throws:
    
    IllegalArgumentException - If an illegal argument is passed to the method
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    BufferUnderflowException - If the capacity of the BytesStore was exceeded
    
    IndexOutOfBoundsException - If the specified indexes for the BytesStore are out of range
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - appendDateMillis
```
@NotNull
public @NotNull Bytes<Void> appendDateMillis(long dateInMillis)
                                               throws BufferOverflowException,
                                                      IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Converts a specified long number to a date in the format yyyymmdd and appends the date to this. The specified long number represents a point in time that is time milliseconds after January 1, 1970 00:00:00 GMT.
    
    Specified by:
    
    appendDateMillis in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    dateInMillis - the specified long to convert to date and append to this
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - appendTimeMillis
```
@NotNull
public @NotNull Bytes<Void> appendTimeMillis(long timeOfDayInMillis)
                                               throws BufferOverflowException,
                                                      IllegalStateException,
                                                      IllegalArgumentException
```
    Description copied from interface: ByteStringAppender
    
    Converts a specified long number to time of day and appends it to this. The specified long number represents time in milliseconds after 00:00:00.000 GMT which will be converted to hours, minutes, seconds and milliseconds.
    Twelve bytes in the format of hh:mm:ss.ddd will be appended to this. hh, mm, ss and ddd represent hour, minute, second and millisecond.
    
    Specified by:
    
    appendTimeMillis in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    timeOfDayInMillis - the long number that represents time of day in milliseconds
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalArgumentException - If an illegal argument is passed to the method
    
    IllegalStateException
  - append
```
@NotNull
public @NotNull Bytes<Void> append(@NotNull
                                            @NotNull BigDecimal bigDecimal)
```
    Description copied from interface: ByteStringAppender
    
    Appends a string representation of a specified BigDecimal to this.
    The string representation of the BigDecimal number is a standard canonical string form as described in BigDecimal.toString().
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    bigDecimal - the specified BigDecimal to append
    
    Returns:
    
    this
    
    See Also:
    
    BigDecimal
  - append
```
@NotNull
public @NotNull Bytes<Void> append(float f)
                                     throws BufferOverflowException,
                                            IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a float in decimal notation
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    f - the float number to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the relative append operation exceeds the underlying buffer's capacity
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - append
```
@NotNull
public @NotNull Bytes<Void> append(double d)
                                     throws BufferOverflowException,
                                            IllegalStateException
```
    Description copied from interface: ByteStringAppender
    
    Appends a double in decimal notation
    
    Specified by:
    
    append in interface ByteStringAppender<Bytes<Void>>
    
    Parameters:
    
    d - to append
    
    Returns:
    
    this
    
    Throws:
    
    BufferOverflowException - If the capacity of the underlying buffer was exceeded
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    IllegalStateException
  - writeMarshallableLength16
```
public void writeMarshallableLength16(@NotNull
                                      @NotNull WriteBytesMarshallable marshallable)
                               throws BufferOverflowException,
                                      BufferUnderflowException,
                                      IllegalStateException,
                                      net.openhft.chronicle.core.io.InvalidMarshallableException
```
    Description copied from interface: Bytes
    
    Writes the content of the provided marshallable into this Bytes object, including a 16-bit length indicator preceding the actual object data. The length indicator denotes the number of bytes taken up by the object data.
    This method is useful for serialization, as it writes not only the content of the marshallable object but also information about its size.
    
    Specified by:
    
    writeMarshallableLength16 in interface Bytes<Void>
    
    Specified by:
    
    writeMarshallableLength16 in interface BytesOut<Void>
    
    Parameters:
    
    marshallable - The object to be serialized and written to this Bytes object. Must not be null.
    
    Throws:
    
    BufferOverflowException - If there is not enough capacity in this Bytes object to store the serialized data.
    
    BufferUnderflowException - If there is not enough data available in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way.
    
    net.openhft.chronicle.core.io.InvalidMarshallableException - If the object cannot be written due to invalid data.
    
    IllegalStateException
    
    See Also:
    
    Bytes.readMarshallableLength16(Class, ReadBytesMarshallable)
  - write
```
public Bytes<?> write(@NotNull
                      @NotNull InputStream inputStream)
               throws IOException,
                      IllegalStateException,
                      BufferOverflowException
```
    Description copied from interface: Bytes
    
    Writes the contents of the provided inputStream into this Bytes object. Continues reading from the inputStream and writing into this Bytes object until the end of the stream is reached.
    Note: This method does not close the provided inputStream.
    
    Specified by:
    
    write in interface Bytes<Void>
    
    Parameters:
    
    inputStream - The input stream from which data is to be read. Must not be null.
    
    Returns:
    
    This Bytes object.
    
    Throws:
    
    IOException - If an I/O error occurs when reading from the inputStream.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there is not enough capacity in this Bytes object to write the data read from the input stream.
    
    IllegalStateException
  - writeStopBit
```
@NotNull
public @NotNull Bytes<Void> writeStopBit(long x)
                                           throws BufferOverflowException,
                                                  IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a stop bit encoded long to the data stream. Stop bit encoding is a form of variable-length integer encoding that uses the continuation bit to indicate if there are more bytes to be processed.
    
    Specified by:
    
    writeStopBit in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    x - The long value to be written to the data stream.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeStopBit
```
@NotNull
public @NotNull Bytes<Void> writeStopBit(char x)
                                           throws BufferOverflowException,
                                                  IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a stop bit encoded char to the data stream. Stop bit encoding is a form of variable-length integer encoding that uses the continuation bit to indicate if there are more bytes to be processed.
    
    Specified by:
    
    writeStopBit in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    x - The char value to be written to the data stream.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeStopBit
```
@NotNull
public @NotNull Bytes<Void> writeStopBit(double d)
                                           throws BufferOverflowException,
                                                  IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a stop bit encoded double value to the data stream. Stop bit encoding is a form of variable-length integer encoding that uses the continuation bit to indicate if there are more bytes to be processed.
    
    Specified by:
    
    writeStopBit in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    d - The double value to be written to the data stream.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeStopBitDecimal
```
@NotNull
public @NotNull Bytes<Void> writeStopBitDecimal(double d)
                                                  throws BufferOverflowException,
                                                         IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a double value to the data stream with a stop bit encoded decimal. The encoding used aims to efficiently store values with a small number of significant digits.
    
    Specified by:
    
    writeStopBitDecimal in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    d - The double value to be written to the data stream.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeUtf8
```
@NotNull
public @NotNull Bytes<Void> writeUtf8(@Nullable
                                               @Nullable CharSequence text)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               IllegalArgumentException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a UTF-8 encoded string to the data stream, similar to writeUTF, but with a few differences. Firstly, the length is stop bit encoded, meaning that the length encoding may be one byte longer for short strings, but the string's length is not limited. Secondly, the string can be null.
    
    Specified by:
    
    writeUtf8 in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    text - The string to be written. Can be null.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    IllegalArgumentException
  - writeUtf8
```
@NotNull
public @NotNull Bytes<Void> writeUtf8(@Nullable
                                               @Nullable String text)
                                        throws BufferOverflowException,
                                               IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a UTF-8 encoded String to the data stream. This method is functionally similar to writeUtf8(CharSequence), but it specifically accepts a String as an argument.
    
    Specified by:
    
    writeUtf8 in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    text - The string to be written. Can be null.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - write8bit
```
@NotNull
public @NotNull Bytes<Void> write8bit(@Nullable
                                               @Nullable CharSequence text)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               BufferUnderflowException,
                                               ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a CharSequence as an 8-bit string to the data stream. If the CharSequence is null, a stop bit encoded -1 is written. If the CharSequence is an instance of BytesStore, the contents are written directly from the BytesStore. Otherwise, the method delegates to the write8bit(String) or write8bit(CharSequence, int, int) as appropriate.
    
    Specified by:
    
    write8bit in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    text - The CharSequence to be written. Can be null.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    BufferUnderflowException
    
    ArithmeticException
  - write8bit
```
@NotNull
public @NotNull Bytes<Void> write8bit(@NotNull
                                               @NotNull CharSequence text,
                                               int start,
                                               int length)
                                        throws BufferOverflowException,
                                               IndexOutOfBoundsException,
                                               IllegalStateException,
                                               BufferUnderflowException,
                                               ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a subsequence of a CharSequence as an 8-bit string to the data stream. If the CharSequence is an instance of String, the method delegates to the write8bit(String, int, int).
    
    Specified by:
    
    write8bit in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    text - The CharSequence to be written.
    
    start - The index of the first char in the CharSequence to write.
    
    length - The number of chars from the CharSequence to write.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IndexOutOfBoundsException
    
    IllegalStateException
    
    BufferUnderflowException
    
    ArithmeticException
  - write8bit
```
@NotNull
public @NotNull Bytes<Void> write8bit(@NotNull
                                               @NotNull String text,
                                               int start,
                                               int length)
                                        throws BufferOverflowException,
                                               IndexOutOfBoundsException,
                                               IllegalStateException,
                                               BufferUnderflowException,
                                               ArithmeticException
```
    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<Void>>
    
    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:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException
    
    IndexOutOfBoundsException
    
    IllegalStateException
    
    BufferUnderflowException
    
    ArithmeticException
  - write
```
@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull CharSequence text)
                                    throws BufferOverflowException,
                                           IllegalStateException,
                                           IndexOutOfBoundsException
```
    Description copied from interface: StreamingDataOutput
    
    Writes the provided text to this StreamingDataOutput at the current writePosition().
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    text - to write
    
    Returns:
    
    this StreamingDataOutput
    
    Throws:
    
    BufferOverflowException - If the provided text cannot be accommodated.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    IndexOutOfBoundsException
  - write
```
@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull CharSequence text,
                                           int startText,
                                           int length)
                                    throws BufferOverflowException,
                                           IndexOutOfBoundsException,
                                           IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes the provided text to this StreamingDataOutput at the current writePosition()
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    text - to write
    
    startText - offset from where text should be copied from
    
    length - number of characters to write.
    
    Returns:
    
    this StreamingDataOutput
    
    Throws:
    
    BufferOverflowException - If the provided text cannot be accommodated.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IndexOutOfBoundsException
    
    IllegalStateException
  - write8bit
```
@NotNull
public @NotNull Bytes<Void> write8bit(@Nullable
                                               @Nullable String s)
                                        throws BufferOverflowException,
                                               IllegalStateException,
                                               ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a String as an 8-bit string to the data stream. If the string is null, a stop bit encoded -1 is written. Otherwise, the method delegates to the write8bit(String, int, int) method.
    
    Specified by:
    
    write8bit in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    s - The String to be written. Can be null.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    ArithmeticException
  - writeUnsignedByte
```
@NotNull
public @NotNull Bytes<Void> writeUnsignedByte(int i)
                                                throws BufferOverflowException,
                                                       IllegalStateException,
                                                       ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes an unsigned byte to the data stream. The input integer is converted to an unsigned byte using Maths.toUInt8(int) before being written.
    
    Specified by:
    
    writeUnsignedByte in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    i - The integer to be written as an unsigned byte.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    ArithmeticException
  - writeUnsignedShort
```
@NotNull
public @NotNull Bytes<Void> writeUnsignedShort(int u16)
                                                 throws BufferOverflowException,
                                                        IllegalStateException,
                                                        ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes an unsigned short integer to the data stream. The input integer is converted to an unsigned short using Maths.toUInt16(int) before being written.
    
    Specified by:
    
    writeUnsignedShort in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    u16 - The integer to be written as an unsigned short.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    ArithmeticException
  - writeInt24
```
@NotNull
public @NotNull Bytes<Void> writeInt24(int i)
                                         throws BufferOverflowException,
                                                IllegalStateException,
                                                ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes a 24-bit integer to the data stream. The integer is split into a 16-bit short and an 8-bit byte.
    
    Specified by:
    
    writeInt24 in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    i - The integer to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    ArithmeticException
  - writeUnsignedInt24
```
@NotNull
public @NotNull Bytes<Void> writeUnsignedInt24(int i)
                                                 throws BufferOverflowException,
                                                        IllegalStateException,
                                                        ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes an unsigned 24-bit integer to the data stream. The integer is split into a 16-bit short and an 8-bit byte.
    
    Specified by:
    
    writeUnsignedInt24 in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    i - The integer to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
    
    ArithmeticException
  - writeUnsignedInt
```
@NotNull
public @NotNull Bytes<Void> writeUnsignedInt(long i)
                                               throws BufferOverflowException,
                                                      ArithmeticException,
                                                      IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes an unsigned integer to the data stream. The input long is converted to an unsigned integer using Maths.toUInt32(long) before being written.
    
    Specified by:
    
    writeUnsignedInt in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    i - The long to be written as an unsigned integer.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is insufficient space in the buffer.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    ArithmeticException
    
    IllegalStateException
  - write
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    Parameters:
    
    bytes - the RandomDataInput from which data is read.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there is not enough space left in the output stream.
    
    IllegalStateException
  - write
```
public Bytes<Void> write(@NotNull
                         @NotNull BytesStore<?,?> bytes)
                  throws IllegalStateException,
                         BufferOverflowException
```
    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<Void>>
    
    Parameters:
    
    bytes - the BytesStore from which data is read.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there is not enough space left in the output stream.
    
    IllegalStateException
    
    See Also:
    
    StreamingDataInput.read(Bytes)
  - write
```
@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull RandomDataInput bytes,
                                           long offset,
                                           long length)
                                    throws BufferOverflowException,
                                           BufferUnderflowException,
                                           IllegalStateException,
                                           IllegalArgumentException
```
    Description copied from interface: StreamingDataOutput
    
    Writes the specified number of bytes from the provided RandomDataInput object into the output stream, starting from the given read offset. The position of this output stream is updated accordingly, but the read position of the input data is not changed.
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    bytes - the RandomDataInput from which data is read.
    
    offset - the offset at which reading from the RandomDataInput starts.
    
    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.
    
    BufferUnderflowException - If there is not enough data available in the input.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalArgumentException - If the readOffset or length are invalid.
    
    IllegalStateException
  - write
```
@NotNull
public @NotNull Bytes<Void> write(@NotNull
                                           @NotNull BytesStore bytes,
                                           long offset,
                                           long length)
                                    throws BufferOverflowException,
                                           BufferUnderflowException,
                                           IllegalStateException,
                                           IllegalArgumentException
```
    Description copied from interface: StreamingDataOutput
    
    Writes the specified number of bytes from the provided BytesStore into the output stream, starting from the given read offset. It ensures that the output stream has enough capacity to accommodate the incoming bytes. The position of this output stream is updated accordingly, but the read position of the input data is not changed.
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    bytes - the BytesStore from which data is read.
    
    offset - the offset at which reading from the BytesStore starts.
    
    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.
    
    BufferUnderflowException - If there is not enough data available in the input.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalArgumentException - If the readOffset or length are invalid.
    
    IllegalStateException
  - write
```
@NotNull
public @NotNull Bytes<Void> write(byte[] byteArray)
                                    throws BufferOverflowException,
                                           IllegalStateException
```
    Description copied from interface: StreamingDataOutput
    
    Writes all the bytes from the given byteArray into the output stream. The position of the output stream is updated according to the number of bytes written.
    
    Specified by:
    
    write in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    byteArray - the array of bytes to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is not enough space left in the output stream.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeBoolean
```
@NotNull
public @NotNull Bytes<Void> 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<Void>>
    
    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.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    IllegalStateException
  - writeEnum
```
public <E extends Enum<E>> Bytes<Void> writeEnum(@NotNull
                                                 E e)
                                          throws BufferOverflowException,
                                                 IllegalStateException,
                                                 ArithmeticException
```
    Description copied from interface: StreamingDataOutput
    
    Writes an enum value to this output stream by writing the enum's name.
    
    Specified by:
    
    writeEnum in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    e - The enum value to be written.
    
    Returns:
    
    The current StreamingDataOutput instance.
    
    Throws:
    
    BufferOverflowException - If there is not enough space left in the output stream.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    ArithmeticException - If a numeric error occurs.
    
    IllegalStateException
  - writePositionRemaining
```
public void writePositionRemaining(long position,
                                   long length)
                            throws BufferOverflowException
```
    Description copied from interface: StreamingDataOutput
    
    Sets the write position and the remaining length of writable bytes in this Bytes object.
    
    Specified by:
    
    writePositionRemaining in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    position - The new write position.
    
    length - The new length of writable bytes remaining.
    
    Throws:
    
    BufferOverflowException - If the provided position and length exceeds the size of the buffer.
  - writeHistogram
```
public void writeHistogram(@NotNull
                           @NotNull net.openhft.chronicle.core.util.Histogram histogram)
                    throws IllegalStateException,
                           BufferOverflowException
```
    Description copied from interface: StreamingDataOutput
    
    Writes the given Histogram object into this Bytes object.
    
    Specified by:
    
    writeHistogram in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    histogram - The Histogram object to be written.
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there is not enough space in this Bytes object to store the Histogram.
    
    IllegalStateException
  - writeBigDecimal
```
public void writeBigDecimal(@NotNull
                            @NotNull BigDecimal bd)
                     throws IllegalArgumentException,
                            IllegalStateException,
                            BufferOverflowException
```
    Description copied from interface: StreamingDataOutput
    
    Writes the given BigDecimal into this Bytes object.
    
    Specified by:
    
    writeBigDecimal in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    bd - The BigDecimal object to be written.
    
    Throws:
    
    IllegalArgumentException - If the BigDecimal cannot be written.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there is not enough space in this Bytes object to store the BigDecimal.
    
    IllegalStateException
  - writeBigInteger
```
public void writeBigInteger(@NotNull
                            @NotNull BigInteger bi)
                     throws IllegalArgumentException,
                            IllegalStateException,
                            BufferOverflowException
```
    Description copied from interface: StreamingDataOutput
    
    Writes the given BigInteger into this Bytes object.
    
    Specified by:
    
    writeBigInteger in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    bi - The BigInteger object to be written.
    
    Throws:
    
    IllegalArgumentException - If the BigInteger cannot be written.
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there is not enough space in this Bytes object to store the BigInteger.
    
    IllegalStateException
  - writeWithLength
```
public void writeWithLength(@NotNull
                            @NotNull RandomDataInput bytes)
                     throws IllegalStateException,
                            BufferOverflowException
```
    Description copied from interface: StreamingDataOutput
    
    Writes data from the provided RandomDataInput into this Bytes object with prefixed length.
    
    Specified by:
    
    writeWithLength in interface StreamingDataOutput<Bytes<Void>>
    
    Parameters:
    
    bytes - The RandomDataInput source of data to be written.
    
    Throws:
    
    net.openhft.chronicle.core.io.ClosedIllegalStateException - If the resource has been released or closed.
    
    net.openhft.chronicle.core.io.ThreadingIllegalStateException - If this resource was accessed by multiple threads in an unsafe way
    
    BufferOverflowException - If there is not enough space in this Bytes object to store the incoming data.
    
    IllegalStateException
  - singleThreadedCheckReset
```
public void singleThreadedCheckReset()
```
    Specified by:
    
    singleThreadedCheckReset in interface net.openhft.chronicle.core.io.SingleThreadedChecked
  - singleThreadedCheckDisabled
```
public void singleThreadedCheckDisabled(boolean singleThreadedCheckDisabled)
```
    Specified by:
    
    singleThreadedCheckDisabled in interface net.openhft.chronicle.core.io.SingleThreadedChecked

Class HexDumpBytes

Field Summary

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

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

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

Constructor Summary

Method Summary

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

Field Detail

MASK

Constructor Detail

HexDumpBytes

Method Detail

fromText

fromText

offsetFormat

numberWrap

numberWrap

readRemaining

writeRemaining

readLimit

writeLimit

toHexString

hashCode

equals

toString

retainedHexDumpDescription

writeHexDumpDescription

adjustHexDumpIndentation

copy

isElastic

ensureCapacity

bytesStore

compact

clear

isDirectMemory

capacity

addressForRead

addressForWrite

addressForWritePosition

compareAndSwapInt

testAndSetInt

compareAndSwapLong

underlyingObject

move

reserve

release

releaseLast

refCount

addReferenceChangeListener

removeReferenceChangeListener

tryReserve

writeByte

writeShort

writeInt24

writeInt

writeOrderedInt

writeLong

writeOrderedLong

writeFloat

writeDouble

writeVolatileByte

writeVolatileShort

writeVolatileInt

writeVolatileLong

write

write

write